Consideraciones de Memoria cuando tenga como objetivo WebGL
Utilizando plantillas WebGL

WebGL: Interactuando con scripting del navegador

Cuando construya contenidos para la web, usted podría necesitar comunicarse con otros elementos en su página web. O usted podría querer implementar funcionalidad utilizando Web APIs las cuales Unity actualmente no expone por defecto. En ambos casos, usted necesita directamente interactuar con el motor JavaScript del navegador. Unity WebGL proporciona diferentes métodos para hacer esto.

Llamando código JavaScript desde Unity

El primero es lo mismo que para el Web Player. Usted puede utilizar las funciones Application.ExternalCall() y Application.ExternalEval() para invocar el código JavaScript en la página web embebida. Para llamar métodos en GameObjects en su contenido desde el JavaScript de su navegador, usted puede utilizar el siguiente código:

sendMessage ('MyGameObject', 'MyFunction', 'example');

Llamando funciones JavaScript desde un plugin

La otra manera para utilizar JavaScript del navegador en su proyecto es agregar sus fuentes de JavaScript a su proyecto, y luego llamar esas funciones directamente desde su código script. Para hacer esto, coloque los archivos con código Javascript utilizando la extensión .jslib (ya que la .js normal sería cogida por el compilador de UnityScript) a una carpeta “Plugins/WebGL” en su carpeta Assets. El archivo necesita tener una sintaxis como esta:

Assets/Plugins/WebGL/MyPlugin.jslib

var MyPlugin = {
    Hello: function()
    {
        window.alert("Hello, world!");
    },
    HelloString: function(str)
    {
        window.alert(Pointer_stringify(str));
    },
    PrintFloatArray: function(array, size)
    {
        for(var i=0;i<size;i++)
            console.log(HEAPF32[(array>>2)+size]);
    },
    AddNumbers: function(x,y)
    {
        return x + y;
    },
    StringReturnValueFunction: function()
    {
        var returnStr = "bla";
        var buffer = _malloc(lengthBytesUTF8(returnStr) + 1);
        writeStringToMemory(returnStr, buffer);
        return buffer;
    },
    BindWebGLTexture: function(texture)
    {
        GLctx.bindTexture(GLctx.TEXTURE_2D, GL.textures[texture]);
    }
};

mergeInto(LibraryManager.library, MyPlugin);

Then you can call these functions from your C# scripts like this:

using UnityEngine;
using System.Runtime.InteropServices;

public class NewBehaviourScript : MonoBehaviour {

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

    [DllImport("__Internal")]
    private static extern void HelloString(string str);

    [DllImport("__Internal")]
    private static extern void PrintFloatArray(float[] array, int size);

    [DllImport("__Internal")]
    private static extern int AddNumbers(int x, int y);

    [DllImport("__Internal")]
    private static extern string StringReturnValueFunction();

    [DllImport("__Internal")]
    private static extern void BindWebGLTexture(int texture);

    void Start() {
        Hello();
        
        HelloString("This is a string.");
        
        float[] myArray = new float[10];
        PrintFloatArray(myArray, myArray.Length);
        
        int result = AddNumbers(5, 7);
        Debug.Log(result);
        
        Debug.Log(StringReturnValueFunction());
        
        var texture = new Texture2D(0, 0, TextureFormat.ARGB32, false);
        BindWebGLTexture(texture.GetNativeTextureID());
    }
}

Tipos numéricos simples se pueden pasar a JavaScript en parámetros de funciones sin requerir conversión. Otros tipos de datos serán pasados como apuntadores en el heap emscripten (el cual es simplemente un gran arreglo en JavaScript). Para Strings, usted puede utilizar la función de ayuda Pointer_stringify para convertirle en un string JavaScript. Para devolver un valor string usted necesita llamar malloc_ para asignar algo de memoria y luego la función de ayuda writeStringToMemory__ para escribir un string de JavaScript a esta. Si el string es un valor de retorno, entonces el tiempo de ejecución il2cpp se encargará de liberar la memoria para usted. Para arreglos que tengan tipos primitivos, emscripten proporciona diferentes ArrayBufferViews a su heap para diferentes tamaños de enteres, enteros unsigned o representaciones punto flotantes de memoria: HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64. Para acceder a una textura en WebGL, emscripten proporciona el arreglo GL.textures que mapea IDs de textura nativo desde Unity a objetos texture de WebGL. Las funciones WebGL serán llamadas en el contexto de WebGL de emscripten, GLctx.

Llamando funciones C++ desde un plugin

Since Unity compiles your sources into JavaScript from C++ code using emscripten, you can also write plugins in C or C++ code, and call these functions from C#. So, instead of the jslib file in the example above, you could have a c file like below in your project - it will automatically get compiled with your scripts, and you can call functions from it, just like in the JavaScript example above.

If you are using C++ (.cpp) to implement the plugin then you must ensure the functions are declared with C linkage to avoid name mangling issues.

Assets/Plugins/WebGL/MyPlugin.c

#include <stdio.h>

void Hello ()
{
    printf("Hello, world!\n");
}

int AddNumbers (int x, int y)
{
    return x + y;
}

Personalizando Revisiones de Compatibilidad o Manejadores de Errores

Unity va a escribir algo de código JavaScipt a las construcciones por defecto, el cual va a revisar por compatibilidad de plataforma y errores de manejo. Este código va a mostrar errores de advertencia cuando corra en plataformas sin soportar, como cuando se intente correr contenido de Unity WebGL en dispositivos móviles. También va a parse strings de error y excepción del navegador, para revisar por errores conocidos y mostrar diálogos de error con mensajes de error más compresivos.

Usted puede personalizar este manejo, por ejemplo, si usted quiere suprimir los mensajes de error cuando corra en dispositivos móviles. Para hacer esto, abra el index.html generado, y remplace este código con las implementaciones de funciones JavaScript actuales para el manejo de errores y/o revisiones de compatibilidad:

  var Module = {
    TOTAL_MEMORY: 268435456,
    errorhandler: null,
    compatibilitycheck: null,
  };

La función compatibilitycheck será llamada al inicio, y usted puede colocar cualquier código aquí para mostrar mensajes cuando usted detecte que el contenido no es soportado.

La función errorhandler será llamada cuando la página invoque su manejador de eventos window.onerror, y utiliza los mismos parámetros. Devuelva “true” de esta función para resumir su ejecución, y “false” para pasar el error al manejador por defecto de errores de Unity.

Ejemplo:

  var Module = {
    TOTAL_MEMORY: 268435456,
    errorhandler: function(err, url, line) {
        alert("error " + err + " occurred at line " + line);

        // return true so Unity's error handler is not executed.
        return true;
    },
    compatibilitycheck: function() {
        // check compatibility ...
    }
  };
Consideraciones de Memoria cuando tenga como objetivo WebGL
Utilizando plantillas WebGL