Project Features
Framework Features
Hopefully you've found out a bit more about the Homura Project (if not visit the Home Page and About Page for more information). So why would you use Homura? How can Homura help you? What can it do?.
This page aims to enlighten you, illustrating the main benefits that each of the three APIs which comprise the project can provide you when developing web-based or standalone Java-based games applications.
Homura Games Framework - API Features
The Homura games framework utilises Java and OpenGL to provide a high-performance, scene-graph API designed to create the next-generation of web-based, hardware accelerated 3D game applications.
The framework provides a plethora of additional features to assist with the development of these applications, as listed below. To find out more information regarding this API, please go to the project summary page of this site.
 | Homura Game State Management SystemHomura's game state managment system facilitates the separation of game-logic into easily manageable and interoperable blocks. The extensible, Object-Oriented game state system provides a simple mechanism for the encapsulation of common states (GUI, 3D Scenes, 2D Scenes, Physics-based Scenes, Networked Games etc) through inheritance and composition. The managements system is completely customisable allowing you to control the flow of your game application, whilst maintaining a common access point for rendering, input and scene manipulation. |
 | GLSL Shader SupportHomura supports a programmable graphics pipeline within its Scenegraph API, allowing for enhanced rendering functions to be carried out on the GPU, through the incorporation of GLSL Shaders within the Scenegraph. Homura features an introspection system for detecting the capabilities of the Client's hardware and GPU extensions, allowing your games application to balance performance with looks and scale across a variety of desktop hardware specifications, in an unobtrusive manner. |
 | Extensible Set of Common Development TechniquesThe API features OO-encapsulated solutions for a variety of common game development tasks, such as the integration of normal and bump mapping; water rendering; Terrain generation; dynamic sub-pixel filtering algorithms; cartoon, bloom, depth of field and sketch effects; 3D Picking; GUI Systems; Collision Detection and many more. This features can be easily plugged into your game application at various levels (e.g. Game State, Entire Scene, Individual Nodes, Multi-render Passes etc), allowing you to control the granularity of the desired effect. |
 | Powerful 2D/3D Particle Effects SystemHomura integrates two particle effects system's (jME and JOPS), along with each of their bespoke editing tools. This allows effects to be constructed using a simple GUI interface and integratead into your game applications as first-class members of the scene-graph (with complete control over transforms, rendering effects, animation control etc). Homura is distributed with an extensive collection of pre-built effects for a variety of common particle uses such as Smoke, Explosions, Fire, Dust, Clouds, Spell Effects and many more. |
 | Abstracted Physics IntegrationPhysics Integration is provided with Homura as part of both the Game State system and the Scenegraph itself. This allows you to construct global physics properties which act upon an entire scene (Wind, Gravity etc), whilst also constructing scene elements which exhibit individual physical properties (mass, tension, acceleration, friction etc). Homura abstracts the Physics system, providing integration for the popular Bullet and ODE Physics APIs, yet allowing for the custom integration of your Physics API of choice, without impacting on the application code itself. |
 | Pluggable Environment SystemHomura incorporates a pluggable, component-based environment system which provides animated Sky effects for your scenes (as SkyBoxes, SkyDomes, SkyPlanes etc). The system features components for astronomy, weather, day-night cycles, as well as an effects interface for the custom production of your own environmental effects. The system fully integrates with the lighting and fog sub-systems of Homura's renderer for the creation of dynamic lighting effects based on the properties of the environment. |
 | AWT/Swing ConsolidationHomura provides a simple interface for the consolidation of Swing components and Homura's OpenGL based rendering system. This is a two-way system, with either Swing as the primary sub-system with Homura acting as a Swing canvas, or Homura as the primary sub-system with Swing components acting as scene-level elements. The second mechanism supports the use of Swing components in a 3D fashion, with the 3D Picking input system used to trigger UI events. Several uses include: using Swing as a GUI system; incorporating 3D rendering directly within Swing applications; utilising open source Swing components for video rendering, vector graphics etc. The possibilities are endless. |
 | Homura Sprite APIWhilst Homura provides advanced 3D rendering functionality, it is equally as adept at handling 2D graphics. To this end, Homura provides two different systems for the management of Sprite objects within your scenes (one lightweight for tight develop control over the Sprite manipulation, one more heavyweight mechanism which provides automated methods for common sprite uses). Sprites are a first-class member of the Scenegraph, and as such can be used in a variety of rendering modes (Perspective and Parallel projection for the manipulation of Sprites in a three-dimensional manner - i.e. Billboarding, Orthographic projection to use Sprites in a two-dimensional way). |
 | Runtime Statistical ReportingThe Statistical Reporting system within Homura allows developers to visualise the performance of their application during runtime. The system reports details such as texture binds, vertice counts, frame rates, allowing for the analysis of the culling efficiency of the scene, use of textures, poly counts of models and many more. The system is bound to the application in such a manner removing the system and its overhead when converting from development to production builds is as easy as turning off a light. |
 | Runtime Debugging SystemThe runtime debugging system of Homura visualises hidden elements of the scene that typically impact on the execution of sub-systems such as collision detection, lighting, physics etc. This includes information such as Normals, Tangents, Bi-Normals, Joints, Physics forces, Bounding volumes and many more. The debugging system also includes methods to alter the current scene renderer settings such as a wireframe-rendering mode, global ambient lighting, camera perspective changes etc. The debugging system can be utilised with the game state system using composition and inheritance, which, similarly to the reporting system, makes it incredibly easily to remove it when switching between development and production-ready application builds. |
 | Extensible Game Console SystemHomura's Game Console System provides a Quake-style system for the manipulation your application's parameters at run time. The system is extremely flexible through its command processor interface, which allows you to create your own processors to handle input commands. The system is distributed with several pre-built processors : integrated support for run-time Java code execution; JSR-223 Scripting support for JavaScript; a system to execute external scripts upon scene objects; a logo-like command language and many more. |
 | Reflection-based Scene Introspection and ManipulationHomura utilises and extends the jME Scene Monitor to provide a Swing-based, thread-safe GUI system for the run-time introspection and manipulation of the scene graph. The monitor allows you alter characteristics of the scene-graph such as Render States (Textures, Shaders, Lighting, Materials etc), Transforms (Translation, Rotation, Scale) and detects and injects additional API properties such as the Physics system through Java's reflection capabilities. The scene monitor is highly configurable, allowing the integration of custom properties, parameters and event listeners to further extend the capabilities provided. |
Net Homura Web Framework - API Features
The Net Homura web framework utilises common web technologies to provide an easy to use mechanism for the cross-platform, cross-browser deployment of your Homura-based creations.
The framework offers a plethora of additional features to assist your web-based game development endevaours, as listed below. To find out more information regarding this API, please go to the project summary page of this site.
 | Java Web Start-based Deployment SystemHomura applications can be deployed as standalone Java applications, but their real power comes through the use of Java Web Start (JWS) technologies to digitally distribute the games applications through a web browser. Deployment is achieved using JWS' Java Network Launching Protoocol (JNLP), which is utilised by the ubiquitous Java web plugin to download and execute the application on the client's machine. Net Homura facilitates this deployment by providing an easy-to-use, Object Oriented PHP library which dynamically constructs the JNLP deployment descriptor specifying the composition of the game application as an XML document. Net Homura vastly simplifies the deployment process and allows games to be seamlessly integrated into HTML pages. |
 | Next Generation Applet SupportAs well as standalone execution, Net Homura's support for the Java 6-based Next Generation Applet technology means that the games applications can also be embedded directly inside the browser window, without any programmatic changes to the application code. Next Generation applets also make use of the JNLP to describe the deployment mechanism, and Net Homura's deployment toolkit allows the same game application to be deployed as a Web Start, Applet or both through specification of the render target, completely unifying the deployment process. |
 | Cross Platform Development, Deployment and Execution SupportNet Homura utilises standard web-technologies such as PHP,CSS,HTML and JavaScript, in combination with client-side Java technologies to provide a completely cross-platform library, which can run across a multitude of operating systems and web servers including Apache, LigHTTPD, IIS, Tomcat and Glassfish. Combining this with Homura's cross-platform capabilities means that a Homura-based application can be developed, deployed, hosted and executed in an entirely cross-platform way. Using this combination with Linux means that a game can also be constructed using entirely free, open source software, significantly reducing development costs. |
 | Generic Framework for Java ApplicationsWhilst Net Homura deployment system was designed for Homura applications, it's generic approach can be adopted to deploy a wide variety of Java applications (providing they have been architected in a platform-agnostic manner like Homura). There are two ways of deploying other Java applications: using Homura as a lightweight wrapper for the execution of Swing-based applications or directly from the application JARs using Net Homura's PHP deployment toolkit. |
 | Highly Configurable Deployment ProcessNet Homura allows you to fully customise the deployment process, allowing you to visually style the download windows, titles and descriptions of the application, create per-platform settings, customise the Java virtual machine settings such as memory usage (Heap, Stack and Thread allocations), VM generation and type (e.g. Java 6u15 - server edition), download and cache configurations for the application JAR files, update mechanisms (always check for updates, background installation etc), compression levels and many more. The extensive customisation options mean that you can tailor how your application looks and performs for your clients. The deployment process can be linked to various datasource and can be driven from the file-system, using XML templates or through a database, to suit your application needs. |
 | Cross Browser Rendering and DeploymentIn addition to cross-platform support, Net Homura also supports multiple browser environments for both deployment and HTML Rendering. The rendering system is designed to produce markup which performs across the range of modern browser and the server-side and client-side detection systems allow per-browser customisations to be easily incorporated into your web applications. The deployment process has been devised to run smoothly across all major browsers , with Java Web Start deployment compatible with Internet explorer 5.5/6/7/8, Mozilla Firefox 2/3, Google Chrome, Opera 9+ and Apple Safari. Next-generation Applet support is compatible with IE, Firefox and Chrome, with Opera and Safari support to be added in the near-future. |
 | Object-Oriented Templating SystemNet Homura is primarily designed to help Homura game developers rapidly develop a web application in order to deploy their Homura creations, by utilising Object-Oriented concepts and a scenegraph-like methodology to help ease the transition between the two styles of development. Net Homura treats the rendered HTML document like a Homura Game State. A developer can define a common base class to define their application template. The templates are injected with content hooks analogous to scenegraph root nodes in which dynamic content is injected into (the Page scenegraph or DOM). Net Homura is designed to allow developers to use WYSIWYG design tools such Eclipse, Dreamweaver, Expression Web to create their page layouts ,which are then imported into Net Homura with the page content constructed using Net Homura's HTML rendering functions. |
 | Abstracted Database SupportNet Homura aims to separate presentation, content and structure using a tiered architecture. One major part of this architecture is the data access tier, which allows developers to easily bind data-sources to provide data generation and persistence. Net Homura features a system to easily map OO class to relational databases, in an abstract manner, irrespective of database type. Net Homura interoperates with open source relational database management systems such as MySQL and PostgreSQL, as well as integrating with commercial offerings such as Microsoft SQL Server or Oracle. |
 | Scenegraph-like Page Rendering SystemNet Homura's bottom up approach to page construction is designed to assist Homura developers by adopting a scenegraph-like approach to web page construction. HTML Tag structures are rendered as nodes, with visual styles controlled by CSS, and dynamic behaviours controlled by JS. The rendering functions produce clean, standards-compliant markup, without requiring prior knowledge of HTML. All rendering functions combine selectors for CSS styling (like Homura RenderStates) and JavaScript control (like Homura Controllers). The rendering functions mean users can construct a variety of application types such as Image-based brochure sites, user-interoperable data-driven applications, or static content based websites in a clean, consistent manner. |
 | Integration with alternative TechnologiesNet Homura's focus is on integrating standard web technologies on the server-side with Java technologies on the client side to construct Rich Internet Applications(RIAs). However, Net Homura also accomodates for the application of other rich web technologies such as Adobe Flash and Microsoft's Silverlight. Net Homura provides easy-to-use, cross-browser, standards compliant functionality to integrate these technologies to produce engaging, visually appealing web experiences. |
 | Support for Web 2.0 Technologies and Progressive EnhancementNet Homura can be used to create powerful server-side web applications, but has been designed to embrace Web 2.0 technologies to create richer web experiences. Net Homura's rendering architecture is designed to integrate tightly with Asynchronous JavaScript and XML (or AJAX) technologies as well as JavaScript DOM manipulation libraries such as JQuery, Prototype and MooTools. Net Homura's content separation methodology with clean, standards-compliant markup, use of external CSS for content styling and unobstrusive JavaScript combined with Next Generation Applets or client-side execution follows the web-based paradigm of Progressive Enhancement (PE). This paradigm is analogous to Homura in that the web applications produced by Net Homura will scale with the Client's browser and computational capabilities without sacrificing functionality, creating robust web experiences for users of all shapes and sizes. |
Now you know a bit more about Homura, you can start creating the next-generation of web-based games applications. What are you waiting for? Download the entire collection of APIs, technical demos and example games from the downloads section of this site.
