build.gradle

plugins {
    id 'fabric-loom' version '1.13-SNAPSHOT'
    id 'maven-publish'
}

import groovy.json.JsonOutput
import groovy.json.JsonSlurper
import java.security.MessageDigest

def useCpu = project.hasProperty('useCpu') && project.property('useCpu').toString().toLowerCase() == 'true'
def withSourcesJar = project.hasProperty('withSourcesJar') && project.property('withSourcesJar').toString().toLowerCase() == 'true'
def modelRepositorySlug = 'xandergos/terrain-diffusion-30m-onnx'
def modelRepositoryRevision = 'ad2df557eca5645f588766101cf3bc3682455c3e'
def generatedManifestDirectory = layout.buildDirectory.dir('generated/model-assets').get().asFile
def generatedManifestFile = new File(generatedManifestDirectory, 'model-assets-manifest.json')

version = project.mod_version
group = project.maven_group

base {
    archivesName = project.archives_base_name + (useCpu ? '-cpu' : '')
}

loom {
    splitEnvironmentSourceSets()

    mods {
        "terrain-diffusion-mc" {
            sourceSet sourceSets.main
            sourceSet sourceSets.client
        }
    }
}

fabricApi {
    configureDataGeneration {
        client = true
    }
}

repositories {
    // Add repositories to retrieve artifacts from in here.
    // You should only use this when depending on other mods because
    // Loom adds the essential maven repositories to download Minecraft and libraries from automatically.
    // See https://docs.gradle.org/current/userguide/declaring_repositories.html
    // for more information about repositories.
}

dependencies {
    // To change the versions see the gradle.properties file
    minecraft "com.mojang:minecraft:${project.minecraft_version}"
    mappings "net.fabricmc:yarn:${project.yarn_mappings}:v2"
    modImplementation "net.fabricmc:fabric-loader:${project.loader_version}"

    modImplementation "net.fabricmc.fabric-api:fabric-api:${project.fabric_version}"

    if (useCpu) {
        implementation "com.microsoft.onnxruntime:onnxruntime:1.20.0"
        include "com.microsoft.onnxruntime:onnxruntime:1.20.0"
    } else {
        implementation "com.microsoft.onnxruntime:onnxruntime_gpu:1.20.0"
        include "com.microsoft.onnxruntime:onnxruntime_gpu:1.20.0"
    }
}

processResources {
    dependsOn 'generateModelAssetManifest'
    inputs.property "version", project.version
    inputs.property "minecraft_version", project.minecraft_version
    inputs.property "loader_version", project.loader_version
    filteringCharset "UTF-8"
    from(generatedManifestFile) {
        into ''
    }

    filesMatching("fabric.mod.json") {
        expand "version": project.version,
                "minecraft_version": project.minecraft_version,
                "loader_version": project.loader_version
    }
}

def targetJavaVersion = 21
tasks.withType(JavaCompile).configureEach {
    // ensure that the encoding is set to UTF-8, no matter what the system default is
    // this fixes some edge cases with special characters not displaying correctly
    // see http://yodaconditions.net/blog/fix-for-java-file-encoding-problems-with-gradle.html
    // If Javadoc is generated, this must be specified in that task too.
    it.options.encoding = "UTF-8"
    if (targetJavaVersion >= 10 || JavaVersion.current().isJava10Compatible()) {
        it.options.release.set(targetJavaVersion)
    }
}

java {
    def javaVersion = JavaVersion.toVersion(targetJavaVersion)
    sourceCompatibility = javaVersion
    targetCompatibility = javaVersion
    // Only use toolchain if current Java version is less than target
    // Commented out toolchain to avoid detection issues when Java 21 is already installed
    // if (JavaVersion.current() < javaVersion) {
    //     toolchain.languageVersion = JavaLanguageVersion.of(targetJavaVersion)
    // }
    // Loom attaches RemapSourcesJar to "build" when this is enabled. Off by default; use -PwithSourcesJar=true.
    if (withSourcesJar) {
        withSourcesJar()
    }
}

jar {
    from("LICENSE") {
        rename { "${it}_${project.archivesBaseName}" }
    }
}

// configure the maven publication
publishing {
    publications {
        create("mavenJava", MavenPublication) {
            artifactId = project.archives_base_name
            from components.java
        }
    }

    // See https://docs.gradle.org/current/userguide/publishing_maven.html for information on how to set up publishing.
    repositories {
        // Add repositories to publish to here.
        // Notice: This block does NOT have the same function as the block in the top level.
        // The repositories here will be used for publishing your artifact, not for
        // retrieving dependencies.
    }
}

task pipelineTest(type: JavaExec, dependsOn: compileJava) {
    classpath = sourceSets.main.runtimeClasspath
    mainClass = 'com.github.xandergos.terraindiffusionmc.pipeline.PipelineTest'
    jvmArgs '-Xmx8g'
}

tasks.register('generateModelAssetManifest') {
    inputs.property('modelRepositorySlug', modelRepositorySlug)
    inputs.property('modelRepositoryRevision', modelRepositoryRevision)
    outputs.file(generatedManifestFile)

    doLast {
        generatedManifestDirectory.mkdirs()

        String apiUrl = "https://huggingface.co/api/models/${modelRepositorySlug}/revision/${modelRepositoryRevision}?blobs=true"
        Map modelInfo = new JsonSlurper().parseText(new URL(apiUrl).getText('UTF-8')) as Map
        List siblings = modelInfo.siblings as List

        List<String> requiredFiles = [
                'base_model.onnx',
                'coarse_model.onnx',
                'decoder_model.onnx',
                'pipeline_data.json',
                'world_pipeline_config.json'
        ]

        Map<String, Object> assetEntries = [:]
        for (String requiredFileName : requiredFiles) {
            Map siblingEntry = siblings.find { it.rfilename == requiredFileName } as Map
            if (siblingEntry == null) {
                throw new GradleException("Required model asset missing from HF commit ${modelRepositoryRevision}: ${requiredFileName}")
            }

            String resolveUrl = "https://huggingface.co/${modelRepositorySlug}/resolve/${modelRepositoryRevision}/${requiredFileName}?download=true"
            long expectedSizeBytes = ((Number) siblingEntry.size).longValue()
            String expectedSha256
            if (siblingEntry.lfs instanceof Map && siblingEntry.lfs.sha256 != null) {
                expectedSha256 = siblingEntry.lfs.sha256 as String
            } else {
                byte[] remoteFileBytes = new URL(resolveUrl).bytes
                expectedSha256 = sha256Hex(remoteFileBytes)
            }

            assetEntries[requiredFileName] = [
                    sha256: expectedSha256,
                    sizeBytes: expectedSizeBytes,
                    url: resolveUrl
            ]
        }

        Map<String, Object> manifestPayload = [
                repositorySlug: modelRepositorySlug,
                revision: modelRepositoryRevision,
                assets: assetEntries
        ]
        generatedManifestFile.text = JsonOutput.prettyPrint(JsonOutput.toJson(manifestPayload))
    }
}

String sha256Hex(byte[] fileBytes) {
    MessageDigest messageDigest = MessageDigest.getInstance('SHA-256')
    byte[] digestBytes = messageDigest.digest(fileBytes)
    StringBuilder hexBuilder = new StringBuilder(digestBytes.length * 2)
    for (byte digestByte : digestBytes) {
        hexBuilder.append(String.format('%02x', digestByte))
    }
    return hexBuilder.toString()
}