Crear un nuevo proyecto en Unity3D. Ir a “File->Build Settings”, seleccionar la plataforma iOS y luego “Player Settings…”. En “Other Settings” dentro de “Identification” configurar el “Bundle Identifier” por ejemplo con “com.YourCompanyName.YourProductName”

Si no se hace esto dará este error al hacer el “Build”.

NOTA: Si se va a ejecutar en el simulador de Xcode hay que configurar la opción “SDK Version” a una versión de simulador (“iOS Simulator Latest” por ejemplo o la versión de iOS deseada), ya que en caso contrario (si se elige una para dispositivo como por ejemplo “iOS Latest” u otra versión concreta) aparecerán errores acerca de que no están definidas cientos de funciones para la arquitectura i386 al compilar el proyecto de Xcode. Si este paso se hace mal habrá que volver a hacer “Build” en Unity y volver a copiar las carpetas “Libraries” y “Data” a nuestro proyecto Xcode como se va a explicar a continuación.

Una vez configurados el “Bundle Identifier” y la “SDK Version” salvar la escena y el proyecto donde se quiera. Al ejecutar “Build And Run” y se creará un nuevo proyecto de Xcode (llamado “Unity-iPhone”) dentro de la carpeta de nuestro proyecto de Unity con el nombre que nosotros queramos, por ejemplo “iOS Build”. Hay que copiar TODA esa carpeta a otra parte, por ejemplo donde residen tus proyectos de Xcode.

Cuando hagamos algún cambio en nuestro proyecto de Unity y hagamos otra vez “Build” nos pedirá donde guardar el proyecto de Xcode que genera, pero podemos sobreescribir el original (el que se crea dentro de la carpeta de nuestro proyecto Unity) sin problemas. Lo que si habrá que hacer es copiar TODOS los ficheros de las carpetas “Data” y “Libraries” del proyecto Xcode que ha vuelto a crear Unity cuando hace el “Build” a las correspondientes en el proyecto de Xcode que hemos copiado nosotros la primera vez. Se puede usar un script similar a este y ejecutarlo a mano después de hacer “Build”:

#!/bin/bash
cp -Rf ./iOS\ Build/Data ~/Documents/Xcode/my-project/
cp -Rf ./iOS\ Build/Libraries ~/Documents/Xcode/my-project/

De todas maneras la mejor opción para conseguir el mismo efecto es crear un script PostprocessBuildPlayer (ojo que el fichero tenga permisos de ejecución) dentro de “Assets/Editor” (por lo que habrá que crear una carpeta llamada Editor dentro de la vista de “Project” y copiar ahí es script) con el mismo contenido que el anterior para que los ficheros se copien automaticamente a nuestro proyecto de Xcode cada vez que hagamos “Build” en Unity. Los scripts PostprocessBuildPlayer pueden ser shell script o Perl script.

Abrir nuestro proyecto de Xcode y cambiar el nombre del fichero “iPhone_target2AppDelegate.m” (puede tener un nombre diferente según la versión de Unity pero la cuestión es hacerlo en el fichero “AppDelegate”, por tanto será cuestión de ver qué fichero tiene al final puesto precisamente “AppDelegate”) a “iPhone_target2AppDelegate.mm” (es decir 2 emes al final en vez de solo 1). Esto sirve para que Xcode lo compile como código Objetive-C++.

En ese fichero justo encima de “ ...” poner lo siguiente:

static iPhone_target2AppDelegate *delegateObject;

Dentro del método “applicationDidFinishLaunching” añadir la siguiente línea que aparece en negrita como primera instrución a ejecutar:

- (void)applicationDidFinishLaunching:(UIApplication *)application {
    delegateObject = self;
    ...
}

Al final del “AppDelegate” (es decir el fichero “iPhone_target2AppDelegate.mm”), pero antes de la claúsula , poner el siguiente código que crea 2 métodos que pueden ser llamados desde el exterior. Uno de ellos acepta como parámetro una estructura por referencia a la que se modifican sus valores (los métodos usados para obtener el nuevo valor no están creados ya que solo es un ejemplo) y el otro que sin más ejecuta un método del “AppDelegate” que nosotros debemos crear.

NSString* CreateNSString (const char* string) {
    return [NSString stringWithUTF8String: string ? string : ""];
}

char* MakeStringCopy (const char* string) {
    if (string == NULL) return NULL;
    char* res = (char*)malloc(strlen(string) + 1);
    strcpy(res, string);
    return res;
}

struct MyStruct {
    char* stringValue;
    int intValue;
};

extern "C" {    
    void _PassStructFromObjCToUnity ( struct MyStruct *myStruct ) {
        NSLog(@"_PassStructFromObjCToUnity");

        myStruct->stringValue = MakeStringCopy([delegateObject.someStringProperty UTF8String]);
        myStruct->intValue = [delegateObject.someNSNumberProperty intValue];

        printf("-> myStruct->stringValue %s\n", myStruct->stringValue);
        printf("-> myStruct->intValue %i\n", myStruct->intValue);
        NSLog(@"-> complete.");
    }

    void _HaveObjCDoSomething () {
        NSLog(@"_HaveObjCDoSomething");
        [delegateObject doSomething];
        NSLog(@"-> complete.");
    }   
}

Ahora volvemos a nuestro proyecto de Unity y dentro de una clase C# en Assets/Plugins/ podríamos poner algo similar a esto, que sería quien se encargaría de llamar a nuestros métodos definidos dentro de “extern "C"”.

using UnityEngine;
using System.Runtime.InteropServices;

public struct MyStruct
{
    public string stringValue;
    public int intValue;
}

public class OBJCPlugin 
{
    [DllImport ("__Internal")]
    private static extern void _PassStructFromObjCToUnity ( ref MyStruct myStruct );

    public static MyStruct PassStructFromObjCToUnity ()
    {
        Debug.Log("OBJCPlugin.PassStructFromObjCToUnity");
        MyStruct data = new MyStruct();
        if ( Application.platform == RuntimePlatform.IPhonePlayer )
        {
                _PassStructFromObjCToUnity( ref data );
        }
        return data;
    }   

    [DllImport ("__Internal")]
    private static extern void _HaveObjCDoSomething ();

    public static void HaveObjCDoSomething ()
    {
        Debug.Log("OBJCPlugin.HaveObjCDoSomething");
        if ( Application.platform == RuntimePlatform.IPhonePlayer )
        {
                _HaveObjCDoSomething();
        }
    }
}

Como hemos modificado el proyecto de Unity para que llame a las funciones en código nativo de iOS hay que volver a hacer el “Build” y copiar las carpetas “Libraries” y “Data” a nuestro proyecto Xcode (aunque si hemos creado el script PostprocessBuildPlayer las carpetas se copian automáticamente. De esta manera ya se juntan tanto las llamadas hechas desde C# en Unity como el código nativo escrito en nuestro proyecto Xcode.

Si quieres poder ejecutar este proyecto Xcode en el simulador lee el post “Usar el Simulador de Xcode con un plug-in para iOS en Unity 3“.

Fuentes: http://answers.unity3d.com/questions/10110/specific-steps-to-set-up-a-plugin-for-iphone-in-xc.html
http://www.tinytimgames.com/2010/01/10/the-unityobjective-c-divide/