Why call Swift functions from C++ code?

I'm making a game engine in Swift, that uses Box2D as the physics engine. Box2D is a C++ library, and provides many interfaces for accessing collisions that occur in the Box2D world. When you implement `public b2ContactListener` within a C++ header, and set this on the main world pointer with world->SetContactListener(m_customContactListener); you gain direct access to Box2D's collision events, which is crucial for performing game logic that is physics based.

In this example, I want to play a sound when any `BeginContact()` event is fired in Box2D. Swift has a library for initializing an audio context and playing a sound file, let's have a look at the Swift Scene we've created for this purpose.

import MetalKit
import AVFoundation

class SoundScene : Scene {
    var audioPlayer: AVAudioPlayer?
    
    var edgebox: EdgeBox!
    
    override func scrollWheel() {
        (currentCamera as! OrthoCamera).scaleFrame(Mouse.GetDWheel())
    }
    override func buildScene() {
        edgebox = EdgeBox(center: float2(0.0), size: float2(12,12))
        
        addChild(edgebox)
               
        let pathtosound = Bundle.main.path(forResource: "bonk sound", ofType: "wav")!
        audioPlayer = try? AVAudioPlayer(contentsOf: URL(fileURLWithPath: pathtosound))
    }
    
    // this is the function we want to be called by Box2D's BeginContact event listener
    private func _beginContactCallback(_ hit: Bool) {
        if(hit) {
            //sound gets played when the function is called from C++
            audioPlayer?.play()
        } else {
            print("something else")
        }
    }
    
    override func mouseUp() {
        addBoxBody()
    }
 
    private var boxBodies: [InB2] = []
    
    private func addBoxBody() {
        let newBox = InB2(fileNamed: "wood_box")
        boxBodies.append(newBox)
        addChild(newBox)
    }
}

Implementation overview

1. In your Xcode Project > Targets > Build Settings, specify your Objective-C bridging header.
2. Define an Objective C interface that will be used in the project's Bridging header which accepts Objective C function type syntax
3. Implement the ContactListener class in C++ for listening to Box2D collisions with the exact same function type as a parameter for the C++ listener
4. Pass the function from Swift to Objective C and from Obj C to C++
5. Call the function in the C++ CustomContactListener class BeginContact method, and verify that the swift function was called!

1. Set the Objective-C bridging header

// BridgingHeader.h
#ifndef Bridging_Header_h
#define Bridging_Header_h

#import "Box2DBridging.h"
#import "CustomContactBridger.h"

#if TARGET_OS_IOS
#import "../Alien Infiltrators/TextRendering/FontRenderable.h"
#elif TARGET_OS_OSX
#import "../Alien Infiltrators OSX/TextRendering/FontRenderable.h"
#endif

#endif

Make sure also to set the Header Search Paths where your C++ libraries' headers are. In targets > Your OSX target > Build Settings > Search Paths > Header Search paths, set the value to "<DirectoryWithHeaders>"/**

2. Define the Objective-C interface

    // see how it returns nothing, and takes a parameter that is a Bool
    private func _beginContactCallback(_ hit: Bool) {
        if(hit) {
            print("bonk sound played!")
            audioPlayer?.play()
        } else {
            print("something else")
        }
    }

// CustomContactBridger.h
#import <Foundation/Foundation.h>

/// Closure implementation syntax: https://fuckingblocksyntax.com/
@interface CustomContactBridger: NSObject
    
@property (nonatomic, readonly) void (^beginContact)(bool);

- (instancetype)initWithCallbacks:(void*)world beginContactCallback:(void(^)(bool))beginContactCallback;
- (instancetype)init NS_UNAVAILABLE;

+ (void) initialize:(void*)world beginContactCallback:(void(^)(bool))beginContactCallback;

@end

static CustomContactBridger *m_customContactBridger;

3. Implement the ContactListener class in C++ for listening to Box2D collisions with the exact same function type as a parameter for the C++ listener

/// CustomContactListener.h
#ifndef CustomContactListener_h
#define CustomContactListener_h

#include "Box2D.h"
#include <functional>

/// see the warnings in b2WorldCallbacks.h
/// @warning You cannot create/destroy Box2D entities inside these callbacks.
class CustomContactListener: public b2ContactListener {
public:
    CustomContactListener( std::function<void(bool)> beginContactClosure );

    void PreSolve(b2Contact* contact, const b2Manifold* oldManifold);
    
    /// Called when two fixtures begin to touch.
    void BeginContact(b2Contact* contact);

    /// Called when two fixtures cease to touch.
    void EndContact(b2Contact* contact);

    std::function<void(bool)> m_beginContactClosure;
};

#endif /* CustomContactListener_h */

// CustomContactBridger.mm
#include "CustomContactListener.h"
#include "CustomContactBridger.h"
#include "b2World.h"
#include <functional> // I need this again for the CustomContactListener(std::function<void (bool)> beginContactClosure) initializer

static CustomContactListener *m_customContactListener;

CustomContactListener::CustomContactListener(std::function<void (bool)> beginContactClosure) {
    m_beginContactClosure = beginContactClosure;
};

void CustomContactListener::BeginContact(b2Contact* contact) {
    m_beginContactClosure(true); // This is calling the Swift function
};

void CustomContactListener::EndContact(b2Contact* contact) {
    B2_NOT_USED(contact); // we're not doing anything with this yet
};


void CustomContactListener::PreSolve(b2Contact *contact, const b2Manifold *oldManifold) {
    return; // not doing anything with this yet
};

4. Pass the function from Swift to Objective C and from Obj C to C++

// CustomContactBridger.mm
#include "CustomContactListener.h"
#include "CustomContactBridger.h"
#include "b2World.h"
#include <functional>

static CustomContactListener *m_customContactListener;

@implementation CustomContactBridger

@synthesize beginContact = _beginContact;

- (instancetype)initWithCallbacks:(b2World*)world beginContactCallback:(void (^)(bool))beginContactCallback {
    self = [super init];
    
    _beginContact = beginContactCallback;
    return self;
};

+ (void) initialize:(b2World*)world beginContactCallback:(void (^)(bool))beginContactCallback {
    m_customContactBridger = [[CustomContactBridger alloc] initWithCallbacks:world beginContactCallback:beginContactCallback];
    printf("initialized!");
    
    m_customContactListener = new CustomContactListener(beginContactCallback);
    
    world->SetContactListener(m_customContactListener);
    printf("set on world!");

};

@end
//... the rest of the CustomContactListener C++ class definitions

    override func buildScene() {
        ...
        CustomContactBridger.initialize(Box2DBridging.getWorld(), beginContactCallback: _beginContactCallback)
        ...
    }

5. Call the function in the C++ CustomContactListener class BeginContact method, and verify that the swift function was called

Summary of calling Swift functions within C++ code

Why not use C++ modules directly in Swift?

wadetregaskis
May 2024
I've been wondering this too, a bit. It'd be nice to be able (eventually) to produce good-quality C++ APIs atop Swift code. I like to think it opens some doors for using Swift for core implementations while supporting C++ users, rather than the other way around.
...

dima_kozhinov
The C++ header is generated, but nowadays it has become so huge that I have doubts that is will compile without problems on C++ side.
Let me explain what I mean:
...
Example:
My library contains 4 lines of code:

@_cdecl("meaningOfLife")
public func meaningOfLife() -> Int {
    return 42
}

The emitted header for my library contains 3975 lines of code (Swift 6.1.2, Windows platform). I could not even paste it here, as Discourse has a limit on number of lines in one post.