Utiliser une bibliothèque C dans Swift sous Linux

Pour faire suite à l'excellente réponse de MBuhot, je viens de faire cela pour obtenir un "hello world" Swift OpenGL fonctionnant sur quelques systèmes Linux et je peux ajouter un peu plus de détails.

Dans mon cas, j'avais besoin à la fois d'OpenGL et des fonctions GLUT, j'ai donc d'abord créé un module système COpenGL. La source de ce module se trouve sur GitHub, mais il s'agit essentiellement d'un répertoire avec deux fichiers :un Package.swift vide et le module.modulemap suivant :

module COpenGL [system] {
    header "/usr/include/GL/gl.h"
    link "GL"
    export *
}

Notez la majuscule GL dans les options d'en-tête et de lien, dont j'avais besoin pour faire correspondre les en-têtes et les bibliothèques de Mesa.

Pour les fonctions GLUT, j'ai créé un module CFreeGLUT similaire (encore une fois, sur GitHub) avec le module.modulemap suivant :

module CFreeGLUT [system] {
    header "/usr/include/GL/freeglut.h"
    link "glut"
    export *
}

Pour l'application, si vous souhaitez utiliser le Swift Package Manager, vous devrez créer un Package.swift dans le répertoire principal qui ressemble à ceci :

import PackageDescription

let package = Package(
    dependencies: [
        .package(url: "https://github.com/BradLarson/COpenGL.git", from: "1.0.0"),
        .package(url: "https://github.com/BradLarson/CFreeGLUT.git", from: "1.0.0")
    ]
) 

Ce qui précède provient de mes versions GitHub des modules système, mais vous pouvez modifier les chemins pour qu'ils pointent vers des copies locales, si vous le souhaitez.

J'ai utilisé l'application "hello world" du Red Book comme base, qui ressemble à ceci une fois convertie en Swift :

import COpenGL
import CFreeGLUT

func renderFunction() {
    glClearColor(0.0, 0.0, 0.0, 0.0)
    glClear(UInt32(GL_COLOR_BUFFER_BIT))
    glColor3f(1.0, 0.0, 0.0)
    glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0)
    glBegin(UInt32(GL_POLYGON))
        glVertex2f(-0.5, -0.5)
        glVertex2f(-0.5, 0.5)
        glVertex2f(0.5, 0.5)
        glVertex2f(0.5, -0.5)
    glEnd()
    glFlush()
}

var localArgc = CommandLine.argc
glutInit(&localArgc, CommandLine.unsafeArgv)
glutInitDisplayMode(UInt32(GLUT_SINGLE))
glutInitWindowSize(500,500)
glutInitWindowPosition(100,100)
glutCreateWindow("OpenGL - First window demo")
glutDisplayFunc(renderFunction)
glutMainLoop()

Placez-le dans un main.swift fichier dans le sous-répertoire Sources. Exécutez swift build et le Swift Package Manager s'éteindra, téléchargera les modules système, créera l'application et liera les modules à celle-ci.

Si vous ne souhaitez pas utiliser Swift Package Manager, vous pouvez toujours utiliser manuellement ces modules système à partir de la ligne de commande. Pour cela, téléchargez-les dans un répertoire local et référencez-les explicitement lors de la compilation :

swiftc -I ./COpenGL -I ./CFreeGLUT main.swift

Les cartes des modules seront lues et vous pourrez accéder à OpenGL et aux fonctions GLUT depuis votre application Swift sous Linux.

Utilisez un module système pour importer le fichier d'en-tête OpenGL :https://github.com/apple/swift-package-manager/blob/master/Documentation/SystemModules.md

En supposant que vous ayez une disposition de répertoire comme :

COpenGL/
  Package.swift
  module.modulemap
  .git/

YourApp/
  Package.swift
  main.swift
  .git/

le fichier COpenGL/module.modulemap ressemblera à :

module COpenGL [system] {
    header "/usr/include/gl/gl.h"
    link "gl"
    export *
}

Cela doit être créé dans un référentiel git séparé, avec une balise de version :

touch Package.swift
git init
git add .
git commit -m "Initial Commit"
git tag 1.0.0

Déclarez-le ensuite en tant que dépendance dans le fichier YourApp/Package.swift

import PackageDescription

let package = Package(
    dependencies: [
        .Package(url: "../COpenGL", majorVersion: 1)
    ]
) 

Ensuite, dans votre fichier main.swift, vous pouvez l'importer :

import COpenGL
// use opengl calls here...