Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
Gema Metastream
Open 3D Engine (O3DE), el sucesor de Lumberyard, ya está disponible en Developer Preview. Descargar O3DE |
Twitch Metastream es una característica que permite a los emisores personalizar sus transmisiones con superposiciones de estadísticas y eventos de su sesión de juego. Mediante cualquier herramienta de creación web, como Dreamweaver o CoffeeCup, los emisores pueden crear páginas HTML5 personalizadas para controlar la información, los gráficos, el diseño y el funcionamiento de cada superposición única. Metastream permite a los emisores crear experiencias de visualización interactivas más afinadas en cualquiera de sus servicios de streaming favoritos, similar a como lo hacen los emisores de deportes profesionales y de televisión en formato electrónico.
Entre los ejemplos de la información que se muestra en una superposición se incluyen:
-
Arte de personajes
-
Puntos fuertes y débiles de los personajes
-
Clasificaciones de los jugadores
-
Estadísticas de dos líderes en una partida
-
Oros obtenidos
-
Jugadores matados, muertos y necesitados de asistencia
-
Daños tratados
Los emisores pueden cambiar entre diferentes capas gráficas programadas para eventos del juego. También pueden utilizar el estilo de imagen incrustada para mostrar información complementaria como, por ejemplo, un minimapa y estadísticas del equipo en directo.
Para permitir que los emisores utilicen Twitch Metastream, debe hacer lo siguiente:
-
Habilite la gema Metastream en su proyecto.
-
Añada una sola línea de código para cada evento al que desee que accedan los emisores.
Twitch Metastream solo es compatible con Windows.
Adición de la gema Metastream
Habilite la gema Metastream en un proyecto para activar el servidor local HTTP Metastream que se incluye con Lumberyard.
Para habilitar la gema Metastream, consulte Habilitación de gemas.
Opciones de configuración para el servidor HTTP
Después de habilitar Metastream, se incrusta un servidor HTTP en el cliente de juego que actúa como punto de acceso para los datos expuestos. Puede configurar las siguientes opciones para el servidor HTTP.
metastream_enabled
-
Variable de consola de solo lectura (CVAR) que describe el estado actual del servidor HTTP incrustado.
0
= deshabilitado.1
= habilitado. metastream_serverOptions
-
Establece las opciones para el servidor HTTP incrustado. Las opciones son un conjunto de pares
key=value
separados por punto y coma.Si un valor de clave requiere un signo de punto y coma ';' o de igual '=', puede utilizar la macro
$semi
o$equ
.El servidor HTTP incrustado se basa en CivetWeb. Puede consultar la lista completa de opciones que se pueden configurar en:
https://github.com/civetweb/civetweb/blob/master/docs/UserManual.md
Por motivos de seguridad, se pasan por alto las siguientes opciones de CivetWeb:
-
enable_directory_listing
-
cgi_interpreter
-
run_as_user
-
put_delete_auth_file
-
Los archivos que coloque dentro de la raíz del documento serán distribuidos por el servidor HTTP. Consulte Acceso a los datos a través de la API de HTTP.
También puede utilizar los siguientes comandos de la consola:
metastream_start
-
Inicia el servidor HTTP incrustado.
metastream_stop
-
Interrumpe el servidor HTTP incrustado.
Exposición de datos a través de Metastream
Metastream expone datos a través de la API de C++.
API de C++
Control del servidor HTTP
La gema Metastream utiliza la siguiente API para iniciar el servidor HTTP:
bool result; // True when the server is successfully started, false when an error occurs. Metastream::MetastreamRequestBus::BroadcastResult(result,&Metastream::MetastreamRequests::StartHTTPServer);
Si se intenta iniciar el servidor HTTP cuando ya se está ejecutando, ello no produce ningún efecto y la llamada devuelve "true".
La gema Metastream utiliza la siguiente API para detener el servidor HTTP:
Metastream::MetastreamRequestBus::Broadcast(&Metastream::MetastreamRequests::StopHTTPServer);
Si el servidor no se está ejecutando, intentar detener el servidor no produce ningún efecto.
Exposición de datos
La gema Metastream utiliza una API sencilla para exponer los datos en el juego mediante el sistema EBus. Consulte Acceso a los datos a través de la API de HTTP para ver estos valores. En la actualidad, la API de Metastream admite valores de 64 bits sin firmar, firmados, dobles, Vec3, booleanos y cadenas de UTF8. El sistema EBus exige que estas llamadas vayan por separado. Esta API le permite añadir valores a objetos y/o matrices y la caché. Esto permite disponer de un sistema totalmente flexible para exponer datos a un cliente web.
Adición a la caché
Para añadir un objeto a la caché raíz, utilice la siguiente sintaxis:
void MetastreamRequests::AddStringToCache(const char*
table
, const char*key
, const char*value
) void MetastreamRequests::AddBoolToCache(const char*table
, const char*key
, boolvalue
) void MetastreamRequests::AddVec3ToCache(const char*table
, const char*key
, const Vec3 &value
) void MetastreamRequests::AddDoubleToCache(const char*table
, const char*key
, doublevalue
) void MetastreamRequests::AddUnsigned64ToCache(const char*table
, const char*key
, AZ::u64value
) void MetastreamRequests::AddSigned64ToCache(const char*table
, const char*key
, AZ::s64value
) void MetastreamRequests::AddArrayToCache(const char*table
, const char*key
, const char*arrayName
) void MetastreamRequests::AddObjectToCache(const char*table
, const char*key
, const char*objectName
)
Definiciones de los parámetros que se enumeran:
table
-
Nombre de la tabla.
key
-
Nombre de la clave.
value
-
El valor que se debe añadir. Si el valor existe, se actualiza. Si el tipo de valor es booleano, se representa en el documento
JSON
comotrue
ofalse
. Los tipos firmado, sin firma y doble se representa como números JSON; las cadenas son UTF8 y se les aplicará escape, si es necesario. arrayName
-
El nombre de la matriz que se debe añadir. Si no existe matriz, entonces se añade la matriz vacía. La matriz se elimina después de que se añade a la caché.
objectName
-
El nombre del objeto que se debe añadir. Si no existe objeto, entonces se añade un objeto NULO. El objeto se elimina después de que se añade a la caché.
Ninguno de los anteriores devuelve ningún valor.
Adición a matriz
Para añadir un objeto a una matriz, utilice la siguiente sintaxis:
void MetastreamRequests::AddStringToArray(const char*
table
, const char*arrayName
, const char*value
) void MetastreamRequests::AddBoolToArray(const char*table
, const char*arrayName
, boolvalue
) void MetastreamRequests::AddVec3ToArray(const char*table
, const char*arrayName
, const Vec3 &value
) void MetastreamRequests::AddDoubleToArray(const char*table
, const char*arrayName
, doublevalue
) void MetastreamRequests::AddUnsigned64ToArray(const char*table
, const char*arrayName
, AZ::u64value
) void MetastreamRequests::AddSigned64ToArray(const char*table
, const char*arrayName
, AZ::s64value
) void MetastreamRequests::AddObjectToArray(const char*table
, const char* destArrayName, const char*sourceObjectName
)
Definiciones de los parámetros que se enumeran:
table
-
Nombre de la tabla.
arrayName
-
El nombre de la matriz que se debe añadir. Si no existe matriz, entonces se añade una matriz vacía. La matriz se elimina después de que se añade a la caché.
value
-
El valor que se debe añadir a la matriz. Si el tipo de valor es booleano, se representa en el documento JSON como
true
ofalse
. Los tipos firmado, sin firma y doble se representa como números JSON; las cadenas son UTF8 y se les aplicará escape, si es necesario. arrayName
-
El nombre de la matriz a la que se debe añadir. Si no existe matriz, se crea una.
destArrayName
-
El nombre de la matriz de destino a la que se debe añadir. Si no existe matriz, se crea una.
sourceObjectName
-
El nombre del objeto que se debe añadir a la matriz. Si no existe objeto, entonces se añade un objeto NULO. El objeto se elimina después de que se añade a la caché.
Ninguno de los anteriores devuelve ningún valor.
Adición a objeto
Para añadir un objeto a un objeto, utilice la siguiente sintaxis:
void MetastreamRequests::AddArrayToObject(const char*
table
, const char*destObjectName
, const char*key
, const char*srcArrayName
) void MetastreamRequests::AddObjectToObject(const char*table
, const char*destObjectName
, const char*key
, const char*sourceObjectName
) void MetastreamRequests::AddStringToObject(const char*table
, const char*objectName
, const char*key
, const char*value
) void MetastreamRequests::AddBoolToObject(const char*table
, const char*objectName
, const char*key
, boolvalue
) void MetastreamRequests::AddVec3ToObject(const char*table
, const char*objectName
, const char*key
, const Vec3 &value
) void MetastreamRequests::AddDoubleToObject(const char*table
, const char*objectName
, const char*key
, doublevalue
) void MetastreamRequests::AddUnsigned64ToObject(const char*table
, const char*objectName
, const char*key
, AZ::u64value
) void MetastreamRequests::AddSigned64ToObject(const char*table
, const char*objectName
, const char*key
, AZ::s64value
)
Definiciones de los parámetros que se enumeran:
table
-
Nombre de la tabla.
key
-
Nombre de la clave.
objectName
-
El nombre del objeto que se debe añadir. Si no existe un objeto, se crea uno.
value
-
El valor que se debe añadir. Si el valor existe, se actualiza. Si el tipo de valor es booleano, se representa en el documento JSON como
true
ofalse
. Los tipos firmado, sin firma y doble se representa como números JSON; las cadenas son UTF8 y se les aplicará escape, si es necesario. srcArrayName
-
El nombre de la matriz a la que se debe añadir. Si no existe matriz, se crea una. La matriz se elimina después de que se añade al objeto.
sourceObjectName
-
El nombre del objeto que se debe añadir. Si no existe objeto, entonces se añade un objeto NULO. El objeto se elimina después de que se añade a la caché.
Ninguno de los anteriores devuelve ningún valor.
Examples
El siguiente ejemplo muestra cómo utilizar la API C++ de Metastream en un proyecto:
Metastream::MetastreamRequestBus::Broadcast(&Metastream::MetastreamRequestBus::Events::AddToCache, table, key, value);
Cualquier valor que se añada a la caché debe ser compatible con JSON. Para obtener más información, consulte el documento JSON RFC
El siguiente ejemplo muestra cómo reflejar la información del sistema. Básicamente, toda la información se añade a un nombre de objeto, sysInfo
, y este objeto se añade a la caché como systeminfo
.
Objeto compuesto:
Metastream::MetastreamRequestBus::Broadcast( &Metastream::MetastreamRequestBus::Events::AddUnsigned64ToObject, kDataBaseName.c_str(), "sysInfo", "drivespace", GetFreeDriveSpace()); Metastream::MetastreamRequestBus::Broadcast( &Metastream::MetastreamRequestBus::Events::AddUnsigned64ToObject, kDataBaseName.c_str(), "sysInfo", "memoryload", GetMemoryLoad()); Metastream::MetastreamRequestBus::Broadcast( &Metastream::MetastreamRequestBus::Events::AddDoubleToObject, kDataBaseName.c_str(), "sysInfo", "cpuloadsystem", GetCPULoadSystem()); Metastream::MetastreamRequestBus::Broadcast( &Metastream::MetastreamRequestBus::Events::AddDoubleToObject, kDataBaseName.c_str(), "sysInfo", "cpuloadprocess", GetCPULoadProcess()); Metastream::MetastreamRequestBus::Broadcast( &Metastream::MetastreamRequestBus::Events::AddUnsigned64ToObject, kDataBaseName.c_str(), "sysInfo", "tickcount", GetTickCount64()); Metastream::MetastreamRequestBus::Broadcast( &Metastream::MetastreamRequestBus::Events::AddObjectToCache, kDataBaseName.c_str(), "systeminfo", "sysInfo");
Enlaces Lua de Metastream
A partir de Lumberyard 1.10, Twitch Metastream se refleja mediante el contexto de comportamiento, que le permite utilizar Metastream a través de Script Canvas y Lua.
Los siguientes métodos se pueden invocar desde Lua:
-- Controlling the HTTP server: MetastreamRequestBus.Broadcast.StartHTTPServer(); MetastreamRequestBus.Broadcast.StopHTTPServer(); -- Adding to the root cache directly: MetastreamRequestBus.Broadcast.AddStringToCache(table, key, value); -- where value is a string MetastreamRequestBus.Broadcast.AddBoolToCache(table, key, value); -- where value is a bool MetastreamRequestBus.Broadcast.AddDoubleToCache(table, key, value); -- where value is a double MetastreamRequestBus.Broadcast.AddUnsigned64ToCache(table, key, value); -- where value is an unsigned 64-bit number MetastreamRequestBus.Broadcast.AddSigned64ToCache(table, key, value); -- where value is a signed 64-bit number MetastreamRequestBus.Broadcast.AddArrayToCache(table, key, arrayName); -- where arrayName is the name of a temporary array (see below) MetastreamRequestBus.Broadcast.AddObjectToCache(table, key, objectName); -- where objectName is the name of a temporary object (see below) -- Adding to a temporary Array: MetastreamRequestBus.Broadcast.AddStringToArray(table, arrayName, value); MetastreamRequestBus.Broadcast.AddBoolToArray(table, arrayName, value); MetastreamRequestBus.Broadcast.AddDoubleToArray(table, arrayName, value); MetastreamRequestBus.Broadcast.AddUnsigned64ToArray(table, arrayName, value); MetastreamRequestBus.Broadcast.AddSigned64ToArray(table, arrayName, value); MetastreamRequestBus.Broadcast.AddObjectToArray(table, arrayName, objectName); -- Adding to a temporary Object: MetastreamRequestBus.Broadcast.AddStringToObject(table, objectName, key, value); MetastreamRequestBus.Broadcast.AddBoolToObject(table, objectName, key, value); MetastreamRequestBus.Broadcast.AddDoubleToObject(table, objectName, key, value); MetastreamRequestBus.Broadcast.AddUnsigned64ToObject(table, objectName, key, value); MetastreamRequestBus.Broadcast.AddSigned64ToObject(table, objectName, key, value); MetastreamRequestBus.Broadcast.AddArrayToObject(table, objectName, key, arrayName); MetastreamRequestBus.Broadcast.AddObjectToObject(table, objectName, key, objectName);
Acceso a los datos a través de la API de HTTP
Puede acceder a datos del juego expuestos a través de Metastream mediante solicitudes Get de la API HTTP. A continuación, puede utilizar JavaScript para trabajar con los datos.
http://localhost:
port
/pathToFile-
Transmite un archivo de la raíz de documentos. Los tipos de archivos incluyen HTML, CSS, JS, imágenes, sonidos, recursos o activos.
nota La ruta de datos se reserva para datos de Metastream. No será posible obtener acceso a los archivos que se guardan en el directorio
.document_root
/data/ http://localhost:
port
/data-
Devuelve una lista con las tablas de Metastream disponibles que contienen pares
key=value
. http://localhost:
port
/data?table=table_name
-
Devuelve una lista con todas las claves de Metastream en la tabla especificada.
nota Puede recuperar varios pares clave-valor en una sola solicitud enumerando las claves en una lista separada por comas. Por ejemplo,
http://localhost:8082/data?table=sample&key=key1,key2,key3
http://localhost:
port
/data?table=table_name
&key=key_name
-
Devuelve el valor de la clave especificada en la tabla especificada.
nota Es posible recuperar varios pares
key=value
en una sola solicitud enumerando las claves deseadas separadas por comas. Por ejemplo, http://localhost:8082
/data?table=sample
&key=key1,key2,key3
.Para enumerar todas las claves y sus valores para una tabla: http://localhost:
8082
/data?table=sample
&key=*
Las solicitudes de datos se devuelven en el siguiente formato:
Solicitud | Return |
---|---|
/data |
{ "tables": [ "table1", "table2", ... ] } |
/data?table= |
{ "keys": [ "key1", "key2", ... ] } |
/data?table= |
{ "key_name": value } |
/data?table= |
|