Xpell
Xpell
Developer Guide
Background
Modern development process is involved with a lot of interaction (API calls) to external systems and frameworks, although most of the modern systems have a flexible and easy to use API’s the variety of systems, frameworks and services requires a constant translation process for almost every API.
the following defines a typical web site/application system architecture:
If the application is a game, a metaverse application or any ecommerce app that wants to show 3D models of products it will also include a connection to an external 3D engine.
Xpell Real-Time Interpreter
Xpell was developed in order to ease the process of development and the communication with the satellite services, frameworks and systems.
With real-time interpretation/translation abilities using an internal AI engine (NLP for the real-time translation) the Xpell can understand human language (Englishe) and translate it to any required API/Prompt.
Xpell resides within your program and enables you to communicate with almost any internal/external API/Prompt/Service by using a modular architecture.
Xpell Internal Architecture
The following diagram explains the Xpell internal architecture and main components:
- The Xpell interpreter receives an input command in a human language (English – or with more specific prompt using Test/JSON format) and translate it to an XCommand (Xpell basic command)
- The Xcommand is being routed by the Xpell to XModule (Xpell Module that uses as a wrapper to an external engine
- The XModule execute the translated command and creates |(if required) an XObject (Xpell Object that wraps an external object)
Xpell Module
Xpell module uses as a component that wraps an external engine, for example a module which is responsible on the User Interface in a web application will wrap the UI framework (HTML & Javascript in this case) and will create XObjects related to the UI elements like labels, text fields, views and more UI components.
The following diagram defines the Xpell base module that uses as a parent object for every Xpell module:
The XModule is a base class for every module, meaning if you want to develop a new module you need to extend this class.
Properties:
XObjectManager
This component is any module responsible for managing the XObject that this module creates and manages.
The XObjectManager is accessible also via the alias “om” (your_module.om)
Methods:
load
This method runs when the module is being loaded, and can be overridden.
create
Creates an XObject that is being handled by this module.
execute
Execute XCommand on this module
run
Runs a text command on this module (converts the text to an XCommand and calls the execute method).
onFrame
invoked on any frame and bubbles the event to the module XObjects.
ImportIObject
Imports an XObject to the module, imported objects require a name (string) that will be used in the create method.
ImportIObjectPack
Imports an XObject Pack – an object with many XObject to be imported.
Xpell Object
The following diagram defines Xpell object for the system elements:
Properties:
NanoCommands
holds the XObject Xpell NanoCommand (small commands that can be executed directly on the XObject by the Xpell interpreter).
Methods:
init
invoked when the XObject is being initialized, and can be overridden.
dispose
invoked by the XObject Manager when the object is being disposed of by the system.
execute
Execute NanoCommand on this object.
run
Runs a text command on this module (converts the text to an XCommand and calls the execute method).
onFrame
Invoked on any frame by the Xpell engine and bubbles the event to the children XObjects (when overriding make sure to call super.onFrame to bubble the event).
onCreate
This method is being invoked when the XObject is being created by the system.
.onMount
This method is being invoked when the XObject is being mounted to the platform by the system, for example when an HTML element is being mounted to the DOM.
Xpell Basic Modules
The following diagram elaborates on a few types of XModules wrappers that handle User Interface (UI) engines like browsers and devices with native support (ios/android), 3D engines, AI engines and more.
XData
Xpell Real-Time In-Memory Data object, this object is accessible from anywhere within the software (just import XData file) and can store variables and objects.
The XData is used as a cache memory/storage for the application to support real-time performance.
XEM (XEventManager)
Xpell Event Manager, responsible for event triggering (XEM.fire) and listening (XEM.listen).
XEM is accessible from anywhere in the software (import XEM).
Wormholes
Xpell networking object, responsible for all the communication from the client to the server and to other Xpell based services.
XUI
This module handles the User Interface operations, from the web perspective HTML, CSS and Javascript being controlled by XUIObject to provide basic UI components with modularity by design.
XUIObject
This object extends the XObject to and is a base object to all the UI components (Objects).
XUICoreObjects
X3D
The X3D module is responsible for the interaction with the external 3D engine, this module wraps the engine and uses it to create the 3D world/space.
For web applications and platforms X3D wraps Three.JS 3D engine and creates an XObject named X3DObject that wraps the Three.JS 3DObject (https://threejs.org).
XAI
Xpell networking object, responsible for all the communication from the client to