melonjs/melonJS

Features

• 2D Game Engines - Provides a lightweight HTML5 engine for building 2D games with rendering, physics, input, and audio across WebGL and Canvas2D.
• 2D Game Frameworks - A framework that provides sprite animation, tilemap loading, physics simulation, and input handling for browser-based games.
• Physics and Collisions - Ships a SAT-based collision engine with swappable adapters for rigid body physics simulation.
• SAT Collision Detection with Broad-Phase - Apply SAT collision detection with QuadTree or Octree broad-phase, raycasts, and pluggable physics adapters for 2D and 3D scenes.
• Tiled Map Integrations - Integrates with the Tiled editor for designing and loading orthogonal, isometric, and hexagonal game levels.
• Attachable Physics Bodies - Attach a physics body with collision shapes to any renderable to automatically apply gravity, velocity, friction, and collision detection.
• Adapter-Based Physics Abstractions - Provides an adapter-based abstraction that swaps physics engines at startup while keeping gameplay code portable.
• Collision Detection - Fire a callback exactly once when two bodies begin overlapping to enable one-shot responses like stomps or pickups.
• Active Collision Handlers - Fire a callback every frame while two bodies overlap with a normalized contract that works identically across physics adapters.
• Collision End Handlers - Fire a callback when two bodies stop overlapping to enable cleanup or state transitions.
• Collision Event Handlers - Fire callbacks when bodies overlap, with events for start, active, and end of contact.
• Grounded State Detection - Report whether a body is currently in contact with a surface below it using a portable isGrounded method.
• Physics Engine Adapters - Provides a physics engine adapter system that swaps between SAT, Matter.js, and Planck/Box2D at startup.
• Built-in SAT Physics Adapters - Simulate rigid body physics using a built-in SAT-based engine that handles collision detection, force integration, and positional push-out for dynamic and static bodies.
• Separating Axis Theorem Collisions - Implements a SAT-based collision engine with polygon-accurate detection, spatial partitioning, and raycasts.
• Unified Input Handling - Provides a unified input system handling mouse, touch, keyboard, gamepad, and accelerometer events.
• 2D Sprite Animations - Provides sprite animation from texture atlases with tweening, particles, and custom shader effects.
• Sprite Animations from Texture Atlases - Creates sprite animations from texture atlases with named frame sequences exported by tools like TexturePacker.
• Sprite Animations with Tweens and Particles - Ships a complete sprite animation system with tweens, transitions, particles, and Spine 4.3 runtime integration.
• Tiled Map Loadings and Renderings - Parses and renders Tiled tilemaps with animated tilesets, collision shapes, and compressed format support.
• Tiled Map Native Integrations - Provides native integration with the Tiled map editor for loading orthogonal, isometric, hexagonal, and staggered tilemaps.
• 2D Rendering Engines - Provides a rendering API that mirrors HTML5 Canvas patterns, abstracting WebGL and Canvas2D behind a single interface.
• Viewport-Culled Physics Simulations - Integrate and simulate physics bodies only when their renderable is within the camera viewport or has the alwaysUpdate flag set.
• Automatic WebGL Canvas2D Fallback Renderers - Automatically switches between WebGL and Canvas2D backends, running the same game code on either renderer without modification.
• Canvas-WebGL Dual Renderers - Implements a dual renderer that automatically switches between WebGL and Canvas2D backends without code changes.
• Force and Impulse Applications - Provides a portable API for applying Newtonian forces and instantaneous impulses to physics bodies.
• Multi-Device Input Handlers - Respond to mouse, touch, keyboard, gamepad, and accelerometer events through a unified input system.
• 2D Game Engines - An engine for building 2D games in the browser using JavaScript, with support for WebGL and Canvas rendering.
• Plugin Systems - Provides a plugin system for extending engine functionality with official plugins for debugging, maps, and native integration.
• 2.5D Game Scene Renderers - Renders 2.5D game scenes with perspective and orthogonal cameras, GPU-accelerated tilemaps, and 3D meshes.
• Game UI Layouts - Places buttons, text inputs, and containers directly inside the game scene for in-game interfaces.
• Interactive Game UI Components - Provides draggable items, pressable buttons, hover effects, and bitmap-font text for in-game interfaces.
• Physics Body Configurations - Set mass, friction, restitution, gravity scale, and sensor flags in a single bodyDef object instead of post-construction setters.
• Mass and Friction Configurations - Set body mass directly from a density value and apply a single scalar friction value per axis without static or kinetic distinction.
• Runtime Property Accessors - Read and write velocity, position, gravity scale, friction, collision type, mask, and sensor state through a portable set of body methods.
• Sleeping Body Optimization - Skip physics integration for bodies that have settled and remain static, saving CPU cycles on idle objects.
• Viewport-Culled Physics Integration - Limit physics integration to bodies that are visible on screen or marked for always-update.
• Portable Property Accessors - Use portable getter and setter methods for velocity, static state, force application, and sensor mode that work consistently across physics adapters.
• One-Way Platform Collisions - Implements one-way platforms using sensor bodies and manual position snapping for platformer games.
• Spatial Querying Systems - Performs raycasts and AABB region queries against the physics world with consistent results across adapters.
• Velocity-Based Stomp Detection - Ships a stomp detection system that reads body velocity at collision time for reliable enemy stomping.
• Mechanical Joint Constraints - Provides adapter-gated joint creation for spring and hinge constraints between physics bodies.
• 2D and 3D Graphics Rendering - Renders graphics using WebGL or Canvas2D with automatic fallback and supports 3D mesh rendering from OBJ/MTL files.
• 3D Mesh Rendering - Loads Wavefront OBJ models or raw geometry and draws textured triangle meshes with perspective projection and backface culling.
• Audio Playback - Provides audio playback for sound effects and music with keyboard, mouse, and touch input handling.
• Per-Camera Post-Processing Stacks - Stack shader effects like glow, outline, or CRT on a per-camera basis to alter the final rendered image.
• Hybrid 2D/3D Rendering - Renders Wavefront OBJ models and textured triangle meshes with perspective projection within a 2D game engine context.
• Particle Effect Emission - Provides configurable particle emission systems for generating visual effects like fire, smoke, and explosions.
• Per-Sprite Shader Pipelines - Features a per-sprite shader pipeline for applying custom fragment shader effects to individual sprites.
• Per-Sprite Fragment Shader Effects - Stack per-camera shader effects such as glow, outline, CRT, and hologram, plus custom per-sprite fragment shaders.
• Spatial Audio Integration - Positions sounds in 3D space with stereo panning and generates procedural audio primitives.
• Plugin and Subclass Extension Systems - Provides a plugin system and ES6 subclassing for extending engine functionality with custom features.
• Accumulating Force Application - Implements accumulating force application to match external physics engine semantics for portable behavior.
• Game UI Element Composition - Composes draggable items, pressable buttons, and bitmap-font text labels for interactive game interfaces.
• Input Bindings - Map physical keyboard keys or gamepad buttons to named actions and check their state in game logic.
• Game Engine Development - Modern 2D game engine with Tiled map support.
• Game Engines - Lightweight and easy-to-use 2D game engine.
• Game Engines and Frameworks - HTML5 framework for 2D games.

سجل النجوم