build.gradle

plugins {
  id 'cpp'
  id 'java'
  id 'edu.wpi.first.wpilib.repositories.WPILibRepositoriesPlugin' version '2020.2'
  id 'edu.wpi.first.NativeUtils' version '2024.7.0'
  id 'edu.wpi.first.GradleJni' version '1.1.0'
  id 'edu.wpi.first.GradleVsCode' version '2.1.0'
}

repositories {
  mavenCentral()
  maven {
    url = uri("${project.getRootDir()}/grapplefrcdriver/target/zips")
  }
}
if (project.hasProperty('releaseMode')) {
  wpilibRepositories.addAllReleaseRepositories(project)
} else {
  wpilibRepositories.addAllDevelopmentRepositories(project)
}

// Apply C++ configuration
apply from: 'config.gradle'

// Apply Java configuration
dependencies {
    implementation 'edu.wpi.first.cscore:cscore-java:2024.+'
    implementation 'edu.wpi.first.cameraserver:cameraserver-java:2024.+'
    implementation 'edu.wpi.first.ntcore:ntcore-java:2024.+'
    implementation 'edu.wpi.first.wpilibj:wpilibj-java:2024.+'
    implementation 'edu.wpi.first.wpiutil:wpiutil-java:2024.+'
    implementation 'edu.wpi.first.wpimath:wpimath-java:2024.+'
    implementation 'edu.wpi.first.wpiunits:wpiunits-java:2024.+'
    implementation 'edu.wpi.first.hal:hal-java:2024.+'
    implementation "org.ejml:ejml-simple:0.43.1"
    implementation "com.fasterxml.jackson.core:jackson-annotations:2.12.4"
    implementation "com.fasterxml.jackson.core:jackson-core:2.12.4"
    implementation "com.fasterxml.jackson.core:jackson-databind:2.12.4"
    implementation 'edu.wpi.first.thirdparty.frc2024.opencv:opencv-java:4.8.0-2'
}

// Set up exports properly
nativeUtils {
  exportsConfigs {
    // Main library is just default empty. This will export everything
    grapplefrc {
    }
  }

  nativeDependencyContainer {
    libgrapplefrcdriver(getNativeDependencyTypeClass('WPISharedMavenDependency')) {
      version = "2024.3.1"
      groupId = "au.grapplerobotics"
      artifactId = "libgrapplefrcdriver"
      ext = "zip"

      headerClassifier = "headers"
      targetPlatforms = [
        "windowsx86-64",
        "windowsarm64",
        "linuxarm64",
        "linuxx86-64",
        "linuxathena",
        "linuxarm32",
        "osxuniversal"
      ]
    }
  }
}

def rust_triple(targetPlatform) {
  def platformName = targetPlatform.name
  if (platformName == "linuxathena") {
    return "arm-unknown-linux-gnueabi"
  } else if (platformName == "linuxarm32") {
    return "arm-unknown-linux-gnueabihf"
  } else if (platformName == "linuxarm64") {
    return "aarch64-unknown-linux-gnu"
  } else if (platformName == "linuxx86-64") {
    return "x86_64-unknown-linux-gnu"
  } else if (platformName == "osxuniversal") {
    return "x86_64-apple-darwin"
  } else if (platformName == "windowsx86-64") {
    return "x86_64-pc-windows-msvc"
  } else if (platformName == "windowsarm64") {
    return "aarch64-pc-windows-msvc"
  } else {
      println "Unknown target platform $platformName"
      return null
  }
}

def all_binaries = []

model {
  components {
    grapplefrc(NativeLibrarySpec) {
      sources {
        cpp {
          source {
            srcDirs 'src/main/native/cpp'
            include '**/*.cpp'
          }
          exportedHeaders {
            srcDirs 'src/main/native/include'
          }
        }
      }
      nativeUtils.useRequiredLibrary(it, 'wpilib_shared', 'libgrapplefrcdriver')
    }
  }
}

import java.nio.file.Files;
import java.nio.file.StandardCopyOption;

def sets = [
  "hal_shared", "wpiutil_shared"
]

task updateRustLibs() {
  doLast {
    sets.each { set -> {
      nativeUtils.nativeDependencyContainer.getByName(set, libset -> {
        def debugBuildType = nativeUtils.buildTypes.named('debug').get()
        def releaseBuildType = nativeUtils.buildTypes.named('release').get()
        for (targetPlatform in nativeUtils.platforms) {
          def resolved = libset.resolveNativeDependency(targetPlatform, releaseBuildType, java.util.Optional.empty()).get()
          def resolvedDebug = libset.resolveNativeDependency(targetPlatform, debugBuildType, java.util.Optional.empty()).get()

          def headers = []
          def libs = []

          resolved.getLinkFiles().forEach({ f -> libs += f })
          resolvedDebug.getLinkFiles().forEach({ f -> libs += f })
          resolved.getIncludeRoots().forEach({ f -> headers += f })

          def triple = rust_triple(targetPlatform)
          def outdir = project.file("grapplefrcdriver/buildlibs/${triple}")
          new File(outdir, "libs").mkdirs()
          new File(outdir, "headers").mkdirs()

          libs.forEach({ lf ->
            copy {
              from lf
              into "${outdir}/libs"
            }
          })

          headers.forEach({ hd ->
            copy {
              from hd
              into "${outdir}/headers"
            }
          })

          if (targetPlatform.name == "osxuniversal") {
            // 2nd copy needed for arm
            outdir = project.file("grapplefrcdriver/buildlibs/aarch64-apple-darwin")
            new File(outdir, "libs").mkdirs()
            new File(outdir, "headers").mkdirs()

            libs.forEach({ lf ->
              copy {
                from lf
                into "${outdir}/libs"
              }
            })

            headers.forEach({ hd ->
              copy {
                from hd
                into "${outdir}/headers"
              }
            })
          }
        }
      })
    }}
  }
}

apply from: 'publish.gradle'

wrapper {
  gradleVersion '8.5'
}