model-resolver 0.1.0__tar.gz

model_resolver-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Erwan DAYOT
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

model_resolver-0.1.0/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.1
+Name: model-resolver
+Version: 0.1.0
+Summary: 
+License: MIT
+Author: edayot
+Author-email: pro.e.dayot@gmail.com
+Requires-Python: >=3.10,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: beet (>=0.104.1)
+Requires-Dist: black (>=24.4.2,<25.0.0)
+Requires-Dist: pillow (>=10.3.0,<11.0.0)
+Requires-Dist: pyopengl @ git+https://github.com/mcfletch/pyopengl.git@29b79e8966ba2930a5c44829b02dffc1ca600752
+Requires-Dist: rich (>=13.7.1,<14.0.0)
+Requires-Dist: tqdm (>=4.66.2,<5.0.0)
+Requires-Dist: typer (>=0.12.3,<0.13.0)
+Description-Content-Type: text/markdown
+
+# Model Resolver
+
+A beet plugin that render all models in the beet project.
+
+
+## Usage
+
+Add the plugin to your pipeline:
+
+```yaml
+# beet.yaml
+pipeline:
+  (...)  # other plugins you may have
+  - model_resolver
+
+# setup an output directory
+output: build
+
+meta:
+  model_resolver:
+    # load vanilla item models
+    load_vanilla: true
+
+```
+
+Renders are now available in your ctx !
+
+
+## Installation
+
+### Windows
+
+Install https://visualstudio.microsoft.com/fr/visual-cpp-build-tools/ and add C++ build tools in the installation.
+
+### Ubuntu
+
+Generally, you don't need to install anything, but if you have an error, you can try to install the following packages:
+
+```bash
+sudo apt-get -y install \
+    freeglut3-dev \
+    libgl1-mesa-dev \
+    libxcursor-dev \
+    libpulse-dev \
+    libxinerama-dev \
+    libxrandr-dev \
+    libxv-dev \
+    mesa-utils \
+    libgl1-mesa-glx \
+    mesa-common-dev \
+    libglapi-mesa \
+    libgbm1 \
+    libgl1-mesa-dri \
+    libsdl1.2-dev \
+    libfreetype6-dev \
+    xvfb \
+    x11-utils
+```
+
+This is particularly useful in CI, see [the github action](./.github/workflows/artifact.yml) for an example.
+
+### Common installation
+
+Using poetry, add this to your pyproject.toml file:
+
+```toml
+[tool.poetry.dependencies]
+# (other dependencies ...)
+model-resolver = {git = "https://github.com/edayot/model_resolver.git", branch = "master"}
+```
+
+
+
+

model_resolver-0.1.0/README.md

@@ -0,0 +1,73 @@
+# Model Resolver
+
+A beet plugin that render all models in the beet project.
+
+
+## Usage
+
+Add the plugin to your pipeline:
+
+```yaml
+# beet.yaml
+pipeline:
+  (...)  # other plugins you may have
+  - model_resolver
+
+# setup an output directory
+output: build
+
+meta:
+  model_resolver:
+    # load vanilla item models
+    load_vanilla: true
+
+```
+
+Renders are now available in your ctx !
+
+
+## Installation
+
+### Windows
+
+Install https://visualstudio.microsoft.com/fr/visual-cpp-build-tools/ and add C++ build tools in the installation.
+
+### Ubuntu
+
+Generally, you don't need to install anything, but if you have an error, you can try to install the following packages:
+
+```bash
+sudo apt-get -y install \
+    freeglut3-dev \
+    libgl1-mesa-dev \
+    libxcursor-dev \
+    libpulse-dev \
+    libxinerama-dev \
+    libxrandr-dev \
+    libxv-dev \
+    mesa-utils \
+    libgl1-mesa-glx \
+    mesa-common-dev \
+    libglapi-mesa \
+    libgbm1 \
+    libgl1-mesa-dri \
+    libsdl1.2-dev \
+    libfreetype6-dev \
+    xvfb \
+    x11-utils
+```
+
+This is particularly useful in CI, see [the github action](./.github/workflows/artifact.yml) for an example.
+
+### Common installation
+
+Using poetry, add this to your pyproject.toml file:
+
+```toml
+[tool.poetry.dependencies]
+# (other dependencies ...)
+model-resolver = {git = "https://github.com/edayot/model_resolver.git", branch = "master"}
+```
+
+
+

model_resolver-0.1.0/model_resolver/__init__.py

@@ -0,0 +1 @@
+from model_resolver.plugin import *

model_resolver-0.1.0/model_resolver/__main__.py

@@ -0,0 +1,4 @@
+from .cli import app
+
+if __name__ == "__main__":
+    app()

model_resolver-0.1.0/model_resolver/cli.py

@@ -0,0 +1,48 @@
+import typer
+from pathlib import Path
+from beet import run_beet, ProjectConfig
+from time import perf_counter
+from rich import print
+
+app = typer.Typer(
+    rich_markup_mode="markdown",
+)
+
+
+# a simple command
+@app.command()
+def main(
+    # fmt: off
+    load_vanilla: bool = typer.Option(False, help="Load vanilla model"),
+    use_cache: bool = typer.Option(False, help="Use cache for model rendering)"),
+    render_size: int = typer.Option(256, help="Size of the rendered image"),
+    load_dir: Path = typer.Option(Path.cwd(), help="Directory where the resourcepack is located"),
+    output_dir: Path = typer.Option(Path.cwd() / "build", help="Where you want to save the new resourcepack, with new textures corresponding to the model"), 
+    minecraft_version: str = typer.Option("latest", help="Minecraft version to use for vanilla models")
+    # fmt: on
+):
+    """
+    A simple CLI to render models from a resourcepack, can also load vanilla models.
+    """
+    t_start = perf_counter()
+    config = ProjectConfig(
+        pipeline=["model_resolver"],
+        output=output_dir,
+        resource_pack={"load": load_dir, "name": load_dir.name},
+        meta={
+            "model_resolver": {
+                "load_vanilla": load_vanilla,
+                "use_cache": use_cache,
+                "render_size": render_size,
+                "minecraft_version": minecraft_version,
+            },
+        },
+    )
+    with run_beet(config=config) as ctx:
+        pass
+    t_end = perf_counter()
+    print(f"[green][bold]✔️[/bold]  Finished in {t_end - t_start:.2f} seconds [/green]")
+
+
+if __name__ == "__main__":
+    app()

model_resolver-0.1.0/model_resolver/my_glutinit.py

@@ -0,0 +1,47 @@
+# fmt: off
+from OpenGL.GLUT import special
+
+
+
+INITIALIZED = False
+def glutInit( *args ):
+    """Initialise the GLUT library"""
+    INITIALIZED = True
+    if args:
+        arg,args = args[0],args[1:]
+        count = None
+        if isinstance(arg, special.integer_types):
+            # raw API style, (count, values)
+            count = arg
+            if count != len(args):
+                raise ValueError( """Specified count of %s does not match length (%s) of argument list %s"""%(
+                    count, len(args), args,
+                ))
+        elif isinstance( arg, (bytes,special.unicode)):
+            # passing in a sequence of strings as individual arguments
+            args = (arg,)+args 
+            count = len(args)
+        else:
+            args = arg 
+            count = len(args)
+    else:
+        count=0
+        args = []
+    args = [special.as_8_bit(x) for x in args]
+    if not count:
+        count, args = 1, [special.as_8_bit('foo')]
+    holder = (special.ctypes.c_char_p * len(args))()
+    for i,arg in enumerate(args):
+        holder[i] = arg
+    count = special.ctypes.c_int( count )
+    import os 
+    currentDirectory = os.getcwd()
+    try:
+        # XXX need to check for error condition here...
+        special._base_glutInit( special.ctypes.byref(count), holder )
+    finally:
+        os.chdir( currentDirectory )
+    return [
+        holder[i] for i in range( count.value )
+    ]
+glutInit.wrappedOperation = special._simple.glutInit

model_resolver-0.1.0/model_resolver/plugin.py

@@ -0,0 +1,402 @@
+from beet import Context, Model, Texture
+from beet.contrib.vanilla import Vanilla
+from beet.core.cache import Cache
+from beet import NamespaceProxyDescriptor
+from rich import print
+from model_resolver.render import Render
+from copy import deepcopy
+from typing import TypedDict
+from PIL import Image
+import json
+from model_resolver.utils import load_textures
+import numpy as np
+import hashlib
+
+
+def beet_default(ctx: Context):
+    load_vanilla = ctx.meta.get("model_resolver", {}).get("load_vanilla", False)
+    use_cache = ctx.meta.get("model_resolver", {}).get("use_cache", False)
+    render_size = ctx.meta.get("model_resolver", {}).get("render_size", 1024)
+    minecraft_version = ctx.meta.get("model_resolver", {}).get(
+        "minecraft_version", "latest"
+    )
+
+    vanilla = ctx.inject(Vanilla)
+    if not minecraft_version == "latest":
+        vanilla = vanilla.releases[minecraft_version]
+    generated_models = set()
+    generated_textures = set()
+
+    for atlas in ctx.assets.atlases:
+        resolve_atlas(ctx, vanilla, ctx, atlas, generated_textures)
+    if load_vanilla:
+        for atlas in vanilla.assets.atlases:
+            resolve_atlas(ctx, vanilla, vanilla, atlas, generated_textures)
+        render_vanilla(ctx, vanilla, generated_models)
+
+    cache = ctx.cache.get("model_resolver")
+    if not "models" in cache.json:
+        cache.json["models"] = {}
+        cache.json["render_size"] = render_size
+        cache.json["minecraft_version"] = minecraft_version
+        use_cache = False
+    if (
+        not cache.json["render_size"] == render_size
+        or not cache.json["minecraft_version"] == minecraft_version
+    ):
+        use_cache = False
+        cache.json["render_size"] = render_size
+        cache.json["minecraft_version"] = minecraft_version
+
+    models = {}
+    for model in set(ctx.assets.models.keys()):
+        resolved_model = resolve_model(ctx.assets.models[model], vanilla.assets.models)
+        resolved_model = bake_model(
+            resolved_model, ctx, vanilla, model, generated_textures
+        )
+        if not "textures" in resolved_model.data:
+            continue
+        if model in cache.json["models"] and use_cache:
+            img = handle_cache(cache, model, resolved_model, ctx, vanilla)
+            if img is not None:
+                # load cached image in ctx
+                model_name = model.split(":")
+                texture_path = f"{model_name[0]}:render/{model_name[1]}"
+                ctx.assets.textures[texture_path] = Texture(img)
+                continue
+
+        models[model] = resolved_model.data
+
+    models = handle_animations(models, ctx, vanilla, generated_textures)
+
+    if len(models) > 0:
+        Render(models, ctx, vanilla).render()
+
+    clean_generated(ctx, generated_textures, generated_models)
+
+
+def handle_cache(cache: Cache, model, resolved_model, ctx, vanilla):
+    model_hash = hashlib.sha256(str(resolved_model.data).encode()).hexdigest()
+    cached_model_hash = cache.json["models"][model]["model"]
+    if model_hash != cached_model_hash:
+        return None
+
+    textures = load_textures(resolved_model.data["textures"], ctx, vanilla)
+    textures_hash = {}
+    for key in resolved_model.data["textures"]:
+        textures_hash[key] = hashlib.sha256(textures[key].tobytes()).hexdigest()
+    cached_textures_hash = cache.json["models"][model]["textures"]
+    if textures_hash != cached_textures_hash:
+        return None
+
+    # load cached image
+    img_path = cache.get_path(f"{model}.png")
+    img = Image.open(img_path)
+    return img
+
+
+def render_vanilla(ctx: Context, vanilla: Vanilla, models: set[str]):
+    vanilla_models = vanilla.assets.models
+
+    for model in vanilla_models.match("minecraft:*"):
+        if "parent" in vanilla_models[model].data:
+            if vanilla_models[model].data["parent"] == "builtin/entity":
+                continue
+        if model not in ctx.assets.models:
+            ctx.assets.models[model] = vanilla_models[model]
+            models.add(model)
+
+
+class Atlas(TypedDict):
+    type: str
+    textures: list[str]
+    palette_key: str
+    permutations: dict[str, str]
+
+
+def clean_generated(
+    ctx: Context, generated_textures: set[str], generated_models: set[str]
+):
+    for texture in generated_textures:
+        if texture in ctx.assets.textures:
+            del ctx.assets.textures[texture]
+    for model in generated_models:
+        if model in ctx.assets.models:
+            del ctx.assets.models[model]
+
+
+def resolve_atlas(
+    ctx: Context,
+    vanilla: Vanilla,
+    used_ctx: Context | Vanilla,
+    atlas: str,
+    generated_textures: set[str],
+):
+    for source in used_ctx.assets.atlases[atlas].data["sources"]:
+        if source["type"] != "paletted_permutations":
+            continue
+        source: Atlas
+        for texture in source["textures"]:
+            for variant, color_palette in source["permutations"].items():
+                new_texture_path = f"{texture}_{variant}"
+                new_texture_path = resolve_key(new_texture_path)
+
+                palette_key = resolve_key(source["palette_key"])
+                if palette_key in ctx.assets.textures:
+                    palette = ctx.assets.textures[palette_key].image
+                elif palette_key in vanilla.assets.textures:
+                    palette = vanilla.assets.textures[palette_key].image
+
+                color_palette_key = resolve_key(color_palette)
+                if color_palette_key in ctx.assets.textures:
+                    color_palette = ctx.assets.textures[
+                        color_palette_key
+                    ].image  # color palette
+                elif color_palette_key in vanilla.assets.textures:
+                    color_palette = vanilla.assets.textures[
+                        color_palette_key
+                    ].image  # color palette
+
+                grayscale_key = resolve_key(texture)
+                if grayscale_key in ctx.assets.textures:
+                    grayscale = ctx.assets.textures[grayscale_key].image
+                elif grayscale_key in vanilla.assets.textures:
+                    grayscale = vanilla.assets.textures[grayscale_key].image
+
+                new_texture = apply_palette(grayscale, palette, color_palette)
+
+                ctx.assets.textures[new_texture_path] = Texture(new_texture)
+                generated_textures.add(new_texture_path)
+
+
+def apply_palette(
+    texture: Image.Image, palette: Image.Image, color_palette: Image.Image
+) -> Image.Image:
+    new_image = Image.new("RGBA", texture.size)
+    texture = texture.convert("RGBA")
+    palette = palette.convert("RGB")
+    color_palette = color_palette.convert("RGB")
+    for x in range(texture.width):
+        for y in range(texture.height):
+            pixel = texture.getpixel((x, y))
+            color = pixel[:3]
+            alpha = pixel[3]
+            # if the color is in palette_key, replace it with the color from color_palette
+            found = False
+            for i in range(palette.width):
+                for j in range(palette.height):
+                    if palette.getpixel((i, j)) == color:
+                        new_color = color_palette.getpixel((i, j))
+                        new_image.putpixel((x, y), new_color + (alpha,))
+                        found = True
+                        break
+                if found:
+                    break
+            if not found:
+                new_image.putpixel((x, y), pixel)
+    return new_image
+
+
+def resolve_key(key: str) -> str:
+    return f"minecraft:{key}" if ":" not in key else key
+
+
+def merge_model(child: Model, parent: Model) -> Model:
+    merged = parent.data.copy()
+
+    if "textures" in child.data:
+        merged["textures"] = {} if "textures" not in merged else merged["textures"]
+        merged["textures"].update(child.data["textures"])
+    if "elements" in child.data:
+        merged["elements"] = child.data["elements"]
+    if "display" in child.data:
+        for key in child.data["display"].keys():
+            merged["display"][key] = child.data["display"][key]
+    if "ambientocclusion" in child.data:
+        merged["ambientocclusion"] = child.data["ambientocclusion"]
+    if "overrides" in child.data:
+        merged["overrides"] = child.data["overrides"]
+    if "gui_light" in child.data:
+        merged["gui_light"] = child.data["gui_light"]
+
+    return Model(merged)
+
+
+def resolve_model(model: Model, vanilla_models: dict[str, Model]) -> Model:
+    # Do something with the model
+    if "parent" in model.data:
+        resolved_key = resolve_key(model.data["parent"])
+        if resolved_key in [
+            "minecraft:builtin/generated",
+            "minecraft:builtin/entity",
+        ]:
+            return model
+        parent_model = vanilla_models[resolved_key]
+        parent_model = deepcopy(parent_model)
+        parent_model_resolved = resolve_model(parent_model, vanilla_models)
+
+        return merge_model(model, parent_model_resolved)
+    else:
+        return model
+
+
+def bake_model(
+    model: Model,
+    ctx: Context,
+    vanilla: Vanilla,
+    model_name: str,
+    generated_textures: set[str],
+):
+    if "parent" in model.data:
+        if model.data["parent"] in ["builtin/generated"]:
+            if "textures" in model.data:
+                textures = load_textures(model.data["textures"], ctx, vanilla)
+                max = 0
+                for key in textures.keys():
+                    if not key.startswith("layer"):
+                        continue
+                    index = int(key[5:])
+                    if index > max:
+                        max = index
+                img = Image.new("RGBA", (16, 16), (0, 0, 0, 0))
+                for i in range(max + 1):
+                    texture = textures.get(f"layer{i}")
+                    img.paste(texture, (0, 0), texture)
+                new_texture = f"debug:{model_name.replace(':', '/')}"
+                ctx.assets.textures[new_texture] = Texture(img)
+                generated_textures.add(new_texture)
+                return Model(generate_item_model(new_texture))
+    return model
+
+
+def generate_item_model(texture: str):
+    res = {
+        "credit": "Made with Blockbench",
+        "textures": {"particle": texture, "layer": texture},
+        "elements": [
+            {
+                "from": [0, 0, 0],
+                "to": [16, 16, 0],
+                "faces": {"north": {"uv": [0, 0, 16, 16], "texture": "#layer"}},
+            }
+        ],
+        "display": {
+            "thirdperson_righthand": {
+                "rotation": [0, -90, 55],
+                "translation": [0, 4, 0.5],
+                "scale": [0.85, 0.85, 0.85],
+            },
+            "thirdperson_lefthand": {
+                "rotation": [0, 90, -55],
+                "translation": [0, 4, 0.5],
+                "scale": [0.85, 0.85, 0.85],
+            },
+            "firstperson_righthand": {
+                "rotation": [0, -90, 25],
+                "translation": [1.13, 3.2, 1.13],
+                "scale": [0.68, 0.68, 0.68],
+            },
+            "firstperson_lefthand": {
+                "rotation": [0, 90, -25],
+                "translation": [1.13, 3.2, 1.13],
+                "scale": [0.68, 0.68, 0.68],
+            },
+            "ground": {"translation": [0, 2, 0], "scale": [0.5, 0.5, 0.5]},
+            "gui": {"rotation": [180, 0, 180]},
+            "head": {"rotation": [0, 180, 0], "translation": [0, 13, 7]},
+            "fixed": {"rotation": [0, 180, 0]},
+        },
+    }
+    return res
+
+
+def is_animated(texture_path: str, ctx: Context, vanilla: Vanilla):
+    if texture_path in ctx.assets.textures_mcmeta:
+        return True
+    if texture_path in vanilla.assets.textures_mcmeta:
+        return True
+    return False
+
+
+def get_thing(
+    path, ctx_proxy: NamespaceProxyDescriptor, vanilla_proxy: NamespaceProxyDescriptor
+):
+    if path in ctx_proxy:
+        return ctx_proxy[path]
+    if path in vanilla_proxy:
+        return vanilla_proxy[path]
+    raise ValueError(f"Texture {path} not found in ctx or vanilla")
+
+
+def handle_animations(
+    models: dict[str, dict],
+    ctx: Context,
+    vanilla: Vanilla,
+    generated_textures: set[str],
+):
+    for model in set(models.keys()):
+        if not "textures" in models[model]:
+            continue
+        textures = models[model]["textures"]
+        if not any(
+            [is_animated(textures[key], ctx, vanilla) for key in textures.keys()]
+        ):
+            continue
+        frametimes = []
+        animated_cache = {}
+        for key, value in textures.items():
+            if not is_animated(value, ctx, vanilla):
+                continue
+            texture = get_thing(value, ctx.assets.textures, vanilla.assets.textures)
+            texture_mcmeta = get_thing(
+                value, ctx.assets.textures_mcmeta, vanilla.assets.textures_mcmeta
+            )
+            frametime = texture_mcmeta.data["animation"].get("frametime", 1)
+
+            img = texture.image
+            # generate all possible frames for the animation
+            width = img.width
+            height = img.height
+            frames = []
+            for i in range(height // width):
+                cropped = img.crop((0, i * width, width, (i + 1) * width))
+                texture_temp_path = f"debug:{model.replace(':', '/')}/{key}/{i}"
+                ctx.assets.textures[texture_temp_path] = Texture(cropped)
+                generated_textures.add(texture_temp_path)
+                frames.append(texture_temp_path)
+
+            frametimes.append(frametime * len(frames))
+
+            animated_cache[key] = {"frames": frames, "frametime": frametime}
+        total_number_of_frames = np.lcm.reduce(frametimes)
+        L = []
+        for tick in range(total_number_of_frames):
+            current_textures = {}
+            for key, value in animated_cache.items():
+                frametime = value[
+                    "frametime"
+                ]  # the number of ticks a frame is displayed
+                frame_index = (tick // frametime) % len(value["frames"])
+                frame = value["frames"][frame_index]
+                current_textures[key] = frame
+            L.append(current_textures)
+        # group L into chunks where current_textures are the same
+        # for each chunk, create a new model with the textures
+
+        L_grouped = []
+        for i in range(len(L)):
+            if i == 0:
+                L_grouped.append([L[i], 1])
+                continue
+            if L[i] == L[i - 1]:
+                L_grouped[-1][1] += 1
+            else:
+                L_grouped.append([L[i], 1])
+        for i, (current_textures, count) in enumerate(L_grouped):
+            new_model_path = f"{model}/{i}_{count}"
+            new_model = deepcopy(models[model])
+            new_model["textures"].update(current_textures)
+            models[new_model_path] = new_model
+        del models[model]
+
+    return models

model_resolver-0.1.0/model_resolver/render.py

@@ -0,0 +1,547 @@
+from OpenGL.GL import *
+from OpenGL.GLUT import *
+from OpenGL.GLU import *
+from model_resolver.my_glutinit import glutInit
+
+from PIL import Image
+
+from beet import Context, Texture
+from beet.contrib.vanilla import Vanilla
+
+from math import cos, sin, pi
+from rich import print
+import hashlib
+from model_resolver.utils import load_textures
+
+
+class RenderError(Exception):
+    pass
+
+
+class Render:
+    """
+
+    model = {"model:model":{
+        'gui_light': 'side',
+        'display': {
+            'gui': {'rotation': [30, 225, 0], 'translation': [0, 0, 0], 'scale': [0.625, 0.625, 0.625]},
+            'ground': {'rotation': [0, 0, 0], 'translation': [0, 3, 0], 'scale': [0.25, 0.25, 0.25]},
+            'fixed': {'rotation': [-90, 0, 0], 'translation': [0, 0, -16], 'scale': [2.001, 2.001, 2.001]},
+            'thirdperson_righthand': {'rotation': [75, 45, 0], 'translation': [0, 2.5, 0], 'scale': [0.375, 0.375, 0.375]},
+            'firstperson_righthand': {'rotation': [0, 135, 0], 'translation': [0, 0, 0], 'scale': [0.4, 0.4, 0.4]},
+            'firstperson_lefthand': {'rotation': [0, 225, 0], 'translation': [0, 0, 0], 'scale': [0.4, 0.4, 0.4]}
+        },
+        'elements': [
+            {
+                'from': [0, 0, 0],
+                'to': [16, 16, 16],
+                'faces': {
+                    'down': {'texture': '#down', 'cullface': 'down'},
+                    'up': {'texture': '#up', 'cullface': 'up'},
+                    'north': {'texture': '#north', 'cullface': 'north'},
+                    'south': {'texture': '#south', 'cullface': 'south'},
+                    'west': {'texture': '#west', 'cullface': 'west'},
+                    'east': {'texture': '#east', 'cullface': 'east'}
+                }
+            }
+        ],
+        'textures': {
+            'particle': 'simpledrawer:block/drawers_wood_side',
+            'down': '#bottom',
+            'up': '#top',
+            'north': '#front',
+            'east': '#side',
+            'south': '#side',
+            'west': '#side',
+            'top': 'simpledrawer:block/drawers_wood_side',
+            'bottom': 'simpledrawer:block/drawers_wood_side',
+            'side': 'simpledrawer:block/drawers_wood_side',
+            'front': 'simpledrawer:block/drawers_wood_front'
+        },
+        'ambientocclusion': False
+    }}
+
+
+    """
+
+    def __init__(self, models: dict[dict], ctx: Context, vanilla: Vanilla):
+        self.models = models
+        self.ctx = ctx
+        self.vanilla = vanilla
+        self.size = ctx.meta.get("model_resolver", {}).get("render_size", 1024)
+
+        self.model_list = list(self.models.keys())
+        self.model_list.sort()
+        self.current_model_index = 0
+        self.textures_bindings = {}
+        self.textures_size = {}
+        self.textures = load_textures(
+            self.models[self.model_list[self.current_model_index]]["textures"],
+            self.ctx,
+            self.vanilla,
+        )
+        self.reset_camera()
+        self.frame_count = 0
+
+    def reset_camera(self):
+        self.translate = [0, 0, 0]
+        self.rotate = [0, 0, 0]
+
+    def reload(self):
+        self.textures_bindings = {}
+        self.textures = load_textures(
+            self.models[self.model_list[self.current_model_index]]["textures"],
+            self.ctx,
+            self.vanilla,
+        )
+        self.generate_textures_bindings()
+
+    def generate_textures_bindings(self):
+        self.textures_bindings = {}
+        for key, value in self.textures.items():
+            tex_id = glGenTextures(1)
+            glBindTexture(GL_TEXTURE_2D, tex_id)
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
+            img_data = value.tobytes("raw", "RGBA")
+            glTexImage2D(
+                GL_TEXTURE_2D,
+                0,
+                GL_RGBA,
+                value.width,
+                value.height,
+                0,
+                GL_RGBA,
+                GL_UNSIGNED_BYTE,
+                img_data,
+            )
+            self.textures_bindings[key] = tex_id
+            self.textures_size[key] = value.size
+
+    def render(self):
+        glutInit()
+
+        glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH)
+        glutInitWindowSize(self.size, self.size)
+        glutInitWindowPosition(100, 100)
+        glutCreateWindow(b"Isometric View")
+        glutHideWindow()
+        glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_GLUTMAINLOOP_RETURNS)
+        glClearColor(0.0, 0.0, 0.0, 0.0)
+
+        # Enable lighting
+
+        glLightfv(GL_LIGHT0, GL_POSITION, [-0.7, -1.0, 0.7, 0.0])
+        glLightfv(GL_LIGHT0, GL_DIFFUSE, [1.0, 1.0, 1.0, 1.0])
+        glLightfv(GL_LIGHT0, GL_SPECULAR, [0.0, 0.0, 0.0, 1.0])
+        glLightModelfv(GL_LIGHT_MODEL_AMBIENT, [0.5, 0.5, 0.5, 1.0])
+
+        glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE)
+        glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, [1.0, 1.0, 1.0, 1.0])
+        glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 50.0)
+
+        self.reload()
+
+        glutDisplayFunc(self.display)
+        glutReshapeFunc(self.reshape)
+        glutIdleFunc(self.display)
+
+        glutMainLoop()
+
+    def cache_in_ctx(self, img: Image.Image):
+        use_cache = self.ctx.meta.get("model_resolver", {}).get("use_cache", False)
+        if not use_cache:
+            return
+
+        current_model = self.model_list[self.current_model_index]
+        model_hash = hashlib.sha256(
+            str(self.models[current_model]).encode()
+        ).hexdigest()
+
+        textures_hash = {}
+        for key, value in self.textures.items():
+            textures_hash[key] = hashlib.sha256(value.tobytes()).hexdigest()
+
+        cache = self.ctx.cache.get("model_resolver")
+
+        cache.json["models"][current_model] = {
+            "model": model_hash,
+            "textures": textures_hash,
+        }
+        save_path = cache.get_path(f"{current_model}.png")
+        with open(save_path, "wb") as f:
+            img.save(f, "PNG")
+
+    def display(self):
+        try:
+            glClearColor(0.0, 0.0, 0.0, 0.0)
+            img = self.draw_buffer()
+            model_name = self.model_list[self.current_model_index].split(":")
+            texture_path = f"{model_name[0]}:render/{model_name[1]}"
+            self.ctx.assets.textures[texture_path] = Texture(img)
+
+            self.cache_in_ctx(img)
+            self.current_model_index += 1
+            if self.current_model_index >= len(self.model_list):
+                glutLeaveMainLoop()
+                return
+            self.reload()
+            self.reset_camera()
+
+            # glutSwapBuffers()
+        except BaseException as e:
+            glutLeaveMainLoop()
+            raise e
+
+    def reshape(self, width, height):
+        glViewport(0, 0, width, height)
+        glMatrixMode(GL_PROJECTION)
+
+        zoom = 8
+
+        glOrtho(zoom, -zoom, -zoom, zoom, self.size, -self.size)
+        glMatrixMode(GL_MODELVIEW)
+
+    def draw_buffer(self):
+
+        glClearColor(0.0, 0.0, 0.0, 0.0)  # Set clear color to black with alpha 0
+        glEnable(GL_DEPTH_TEST)
+        # add ambient light
+        glEnable(GL_COLOR_MATERIAL)
+
+        glEnable(GL_NORMALIZE)
+        glEnable(GL_LIGHTING)
+        glEnable(GL_LIGHT0)
+
+        # Create a framebuffer object (FBO) for off-screen rendering
+        fbo = glGenFramebuffers(1)
+        glBindFramebuffer(GL_FRAMEBUFFER, fbo)
+
+        # Create a renderbuffer for depth testing
+        depth_buffer = glGenRenderbuffers(1)
+        glBindRenderbuffer(GL_RENDERBUFFER, depth_buffer)
+        glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, self.size, self.size)
+        glFramebufferRenderbuffer(
+            GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depth_buffer
+        )
+
+        # Create a texture to render into
+        render_texture = glGenTextures(1)
+        glBindTexture(GL_TEXTURE_2D, render_texture)
+        glTexImage2D(
+            GL_TEXTURE_2D,
+            0,
+            GL_RGBA,
+            self.size,
+            self.size,
+            0,
+            GL_RGBA,
+            GL_UNSIGNED_BYTE,
+            None,
+        )
+        glFramebufferTexture2D(
+            GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, render_texture, 0
+        )
+
+        # Check framebuffer status
+        if glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE:
+            glBindFramebuffer(GL_FRAMEBUFFER, 0)
+            raise RenderError("Framebuffer is not complete")
+
+        # Render the scene
+        glViewport(0, 0, self.size, self.size)
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+
+        model = self.models[self.model_list[self.current_model_index]]
+        if "elements" in model:
+            for element in model["elements"]:
+                self.draw_element(element)
+
+        # Read the pixel data, including alpha channel
+        pixel_data = glReadPixels(0, 0, self.size, self.size, GL_RGBA, GL_UNSIGNED_BYTE)
+
+        # Create an image from pixel data
+        img = Image.frombytes("RGBA", (self.size, self.size), pixel_data)
+        img = img.transpose(Image.FLIP_TOP_BOTTOM)
+
+        # Release resources
+        glDeleteTextures(1, [render_texture])
+        glDeleteRenderbuffers(1, [depth_buffer])
+        glDeleteFramebuffers(1, [fbo])
+        glDisable(GL_COLOR_MATERIAL)
+        glDisable(GL_NORMALIZE)
+        glDisable(GL_DEPTH_TEST)
+        glDisable(GL_LIGHTING)
+        glDisable(GL_LIGHT0)
+
+        return img
+
+    def draw_element(self, element: dict):
+        glEnable(GL_TEXTURE_2D)
+        from_element = element["from"]
+        to_element = element["to"]
+        rotation = element.get("rotation", None)
+
+        from_element_centered, to_element_centered = self.center_element(
+            from_element, to_element
+        )
+
+        vertices = self.get_vertices(
+            from_element_centered, to_element_centered, rotation
+        )
+
+        # transform the vertices
+        gui = (
+            self.models[self.model_list[self.current_model_index]]
+            .get("display", {})
+            .get(
+                "gui",
+                {
+                    "rotation": [30, 225, 0],
+                    "translation": [0, 0, 0],
+                    "scale": [0.625, 0.625, 0.625],
+                },
+            )
+        )
+        scale = gui.get("scale", [1, 1, 1])
+        translation = gui.get("translation", [0, 0, 0])
+        rotation = gui.get("rotation", [0, 0, 0])
+
+        # reset the matrix
+        glLoadIdentity()
+        glTranslatef(translation[0] / 16, translation[1] / 16, translation[2] / 16)
+        glTranslatef(self.translate[0], self.translate[1], self.translate[2])
+        glRotatef(-rotation[0], 1, 0, 0)
+        glRotatef(rotation[1] + 180, 0, 1, 0)
+        glRotatef(rotation[2], 0, 0, 1)
+        glRotatef(self.rotate[0], 1, 0, 0)
+        glRotatef(self.rotate[1], 0, 1, 0)
+        glRotatef(self.rotate[2], 0, 0, 1)
+        glScalef(scale[0], scale[1], scale[2])
+
+        texture_used = [
+            element["faces"].get("down", None),
+            element["faces"].get("up", None),
+            element["faces"].get("north", None),
+            element["faces"].get("south", None),
+            element["faces"].get("west", None),
+            element["faces"].get("east", None),
+        ]
+        texture_used = [x["texture"].lstrip("#") for x in texture_used if x is not None]
+        texture_used = list(set(texture_used))
+
+        for texture in texture_used:
+            if texture not in self.textures_bindings:
+                continue
+            glBindTexture(GL_TEXTURE_2D, self.textures_bindings[texture])
+            glColor3f(1.0, 1.0, 1.0)
+            # get all the faces with the same texture
+            for face, data in element["faces"].items():
+                if data["texture"].lstrip("#") == texture:
+                    self.draw_face(face, data, vertices, from_element, to_element)
+
+        glDisable(GL_TEXTURE_2D)
+
+    def get_vertices(
+        self, from_element: list, to_element: list, rotation: dict | None
+    ) -> list:
+        x1, y1, z1 = from_element
+        x2, y2, z2 = to_element
+        res = [
+            [x1, y1, z1],
+            [x2, y1, z1],
+            [x2, y2, z1],
+            [x1, y2, z1],
+            [x1, y2, z2],
+            [x2, y2, z2],
+            [x2, y1, z2],
+            [x1, y1, z2],
+        ]
+        if rotation is None:
+            return res
+
+        origin = rotation["origin"]
+        axis = rotation["axis"]
+        angle = rotation["angle"]
+        angle = angle * pi / 180
+
+        for point in res:
+            x, y, z = point
+            x -= origin[0]
+            y -= origin[1]
+            z -= origin[2]
+            if axis == "x":
+                y, z = y * cos(angle) - z * sin(angle), y * sin(angle) + z * cos(angle)
+            elif axis == "y":
+                x, z = x * cos(-angle) - z * sin(-angle), x * sin(-angle) + z * cos(
+                    -angle
+                )
+            elif axis == "z":
+                x, y = x * cos(angle) - y * sin(angle), x * sin(angle) + y * cos(angle)
+            x += origin[0]
+            y += origin[1]
+            z += origin[2]
+            point[0], point[1], point[2] = x, y, z
+        return res
+
+    def center_element(self, from_element: list, to_element: list) -> tuple[list, list]:
+        # return from_element, to_element
+        x1, y1, z1 = from_element
+        x2, y2, z2 = to_element
+
+        center = (8, 8, 8)
+
+        # compute the new from and to
+        from_element = (x1 - center[0], y1 - center[1], z1 - center[2])
+        to_element = (x2 - center[0], y2 - center[1], z2 - center[2])
+        return from_element, to_element
+
+    def draw_face(
+        self,
+        face: str,
+        data: dict,
+        vertices: tuple,
+        from_element: list,
+        to_element: list,
+    ):
+
+        if "uv" in data:
+            uv = data["uv"]
+            uv = [x / 16 for x in uv]
+            rotation = data.get("rotation", 0)
+
+        else:
+            uv = self.get_uv(face, from_element, to_element)
+            rotation = 0
+
+        match face:
+            case "down":
+                vertices_order = [7, 6, 1, 0]
+            case "up":
+                vertices_order = [3, 2, 5, 4]
+            case "south":
+                vertices_order = [4, 5, 6, 7]
+            case "north":
+                vertices_order = [2, 3, 0, 1]
+            case "east":
+                vertices_order = [5, 2, 1, 6]
+            case "west":
+                vertices_order = [3, 4, 7, 0]
+            case _:
+                raise RenderError(f"Unknown face {face}")
+
+        match rotation:
+            case 0:
+                pass
+            case 90:
+                vertices_order = [
+                    vertices_order[1],
+                    vertices_order[2],
+                    vertices_order[3],
+                    vertices_order[0],
+                ]
+            case 180:
+                vertices_order = [
+                    vertices_order[2],
+                    vertices_order[3],
+                    vertices_order[0],
+                    vertices_order[1],
+                ]
+            case 270:
+                vertices_order = [
+                    vertices_order[3],
+                    vertices_order[0],
+                    vertices_order[1],
+                    vertices_order[2],
+                ]
+            case _:
+                raise RenderError(f"Unknown rotation {rotation}")
+
+        rotated_vertices = [vertices[i] for i in vertices_order]
+        texcoords = [(0, 1), (2, 1), (2, 3), (0, 3)]
+        triangulated_vertices = [
+            (rotated_vertices[0], rotated_vertices[1], rotated_vertices[2]),
+            (rotated_vertices[0], rotated_vertices[2], rotated_vertices[3]),
+        ]
+        normals = []
+        for v0, v1, v2 in triangulated_vertices:
+            u = [v1[i] - v0[i] for i in range(3)]
+            v = [v2[i] - v0[i] for i in range(3)]
+            normal = [
+                u[1] * v[2] - u[2] * v[1],
+                u[2] * v[0] - u[0] * v[2],
+                u[0] * v[1] - u[1] * v[0],
+            ]
+            normals.append(normal)
+
+        # glUseProgram(self.program)
+        # print(glGetError())
+        # self.set_uniforms(self.program)
+
+        glBegin(GL_QUADS)
+        for i, (v0, v1, v2) in enumerate(triangulated_vertices):
+            normal = normals[i]
+            glNormal3fv(normal)
+
+        for i, (uv0, uv1) in enumerate(texcoords):
+            glTexCoord2f(uv[uv0], uv[uv1])
+            glVertex3fv(rotated_vertices[i])
+        glEnd()
+        # glUseProgram(0)
+
+    def get_uv(self, face: str, from_element: list, to_element: list):
+
+        x1, y1, z1 = from_element
+        x2, y2, z2 = to_element
+
+        div = 16
+
+        x1, y1, z1 = x1 / div, y1 / div, z1 / div
+        x2, y2, z2 = x2 / div, y2 / div, z2 / div
+
+        match face:
+            case "east":
+                return (z1, y1, z2, y2)
+            case "west":
+                return (z1, y1, z2, y2)
+            case "up":
+                return (x1, z1, x2, z2)
+            case "down":
+                return (x1, z1, x2, z2)
+            case "south":
+                return (x1, y1, x2, y2)
+            case "north":
+                return (x1, y1, x2, y2)
+
+    def keyboard(self, key, x, y):
+        # increment the current model index on each click
+        if key == b"\x1b":
+            glutLeaveMainLoop()
+        elif key == b"r":
+            self.current_model_index += 1
+            self.current_model_index = self.current_model_index % len(self.models)
+            self.reload()
+            self.reset_camera()
+        elif key == b"z":
+            self.translate[1] += 1
+        elif key == b"s":
+            self.translate[1] -= 1
+        elif key == b"q":
+            self.translate[0] -= 1
+        elif key == b"d":
+            self.translate[0] += 1
+        # use ijklm to rotate the model
+        elif key == b"i":
+            self.rotate[0] += 1
+        elif key == b"k":
+            self.rotate[0] -= 1
+        elif key == b"j":
+            self.rotate[1] += 1
+        elif key == b"l":
+            self.rotate[1] -= 1
+        elif key == b"u":
+            self.rotate[2] += 1
+        elif key == b"m":
+            self.rotate[2] -= 1
+
+        glutPostRedisplay()

model_resolver-0.1.0/model_resolver/utils.py

@@ -0,0 +1,40 @@
+from PIL import Image
+from beet import Context
+from beet.contrib.vanilla import Vanilla
+
+
+def load_textures(
+    textures: dict, ctx: Context, vanilla: Vanilla
+) -> dict[str, Image.Image]:
+    res = {}
+    for key in textures.keys():
+        value = get_real_key(key, textures)
+        if value == "__not_found__":
+            res[key] = Image.new("RGBA", (16, 16), (0, 0, 0, 0))
+        else:
+            res[key] = load_texture(value, ctx, vanilla)
+    return res
+
+
+def load_texture(path: str, ctx: Context, vanilla: Vanilla) -> Image.Image:
+    path = f"minecraft:{path}" if ":" not in path else path
+    if path in ctx.assets.textures:
+        texture = ctx.assets.textures[path]
+    elif path in vanilla.assets.textures:
+        texture = vanilla.assets.textures[path]
+    else:
+        raise KeyError(f"Texture {path} not found")
+    img: Image.Image = texture.image
+    img = img.convert("RGBA")
+    return img
+
+
+def get_real_key(key: str, textures: dict, max_depth: int = 10) -> str:
+    if max_depth == 0:
+        return "__not_found__"
+    if key not in textures:
+        return "__not_found__"
+    if textures[key][0] == "#":
+        return get_real_key(textures[key][1:], textures, max_depth - 1)
+    else:
+        return textures[key]

model_resolver-0.1.0/pyproject.toml

@@ -0,0 +1,43 @@
+[tool.poetry]
+name = "model-resolver"
+version = "0.1.0"
+description = ""
+authors = ["edayot <pro.e.dayot@gmail.com>"]
+license = "MIT"
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.10"
+beet = ">=0.104.1"
+tqdm = "^4.66.2"
+rich = "^13.7.1"
+pyopengl = {git = "https://github.com/mcfletch/pyopengl.git", rev = "29b79e8966ba2930a5c44829b02dffc1ca600752"}
+pillow = "^10.3.0"
+black = "^24.4.2"
+typer = "^0.12.3"
+
+[tool.poetry.scripts]
+model_resolver = "model_resolver.cli:app"
+
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+
+[tool.beet]
+output="build"
+pipeline=[
+    "model_resolver"
+]
+
+
+[tool.beet.resource_pack]
+load = "."
+
+[tool.beet.meta.model_resolver]
+load_vanilla = true
+use_cache = false
+render_size = 256
+minecraft_version = "latest"
+