• [转]Game Engines


    http://content.gpwiki.org/index.php/Game_Engines

    A game engine is the core library functions used in a game, usually related to graphics, input, sound, networking and other systems.

    Engines are separate from game-specific code, which enables different games to use the same engine. (Games of different genres even, in some cases.)

    Engines have different features. When picking an engine, you have to pay attention to whether or not it satisfies the needs of your game.

     

    Engine Overview

    Game engines

    Name clip_image001

    Language clip_image001[1]

    Platform clip_image001[2]

    License clip_image001[3]

    Graphics clip_image001[4]

    Soundclip_image001[5]

    Networkingclip_image001[6]

    Scriptingclip_image001[7]

    Other features clip_image001[8]

    Plus clip_image001[9]

    Minus clip_image001[10]

    A6 Game Engine

    C-script like language/C++/Delphi

    clip_image003

    Commercial

    3D via DirectX

    clip_image005

    clip_image005[1]

    clip_image005[2]clip_image006

    Physics

    Adventure Game Studio (AGS)

    C++

    clip_image003[1] clip_image008

    Open source (Artistic License v2)

    Allegro

    clip_image005[3]

    clip_image005[4]

    clip_image005[5]clip_image006[1]

    Supports user-made plugins and modules

    AgateLib

    .NET

    clip_image003[2] clip_image006[2]

    Free

    2D via Direct3D or OpenGL

    clip_image005[6]

    clip_image010

    clip_image010[1]

    AGen

    C++

    clip_image003[3]

    Indie/Commercial

    Hardware accelerated 2D via Direct3D or OpenGL

    clip_image005[7]

    clip_image005[8]

    clip_image005[9] clip_image006[3]

    Physics

    Scene management, high-level framework, automatic memory management

    Not cross platform yet

    Allegro

    C

    clip_image008[1] clip_image003[4] clip_image012 clip_image013

    Free (Open Source)

    2D and 3D

    clip_image005[10]

    clip_image010[2]

    clip_image010[3]

    APlay

    C#, C# for Unity, Flash, Java (server), AWT

    clip_image003[5] clip_image013[1] clip_image008[2]

    Free and commercial

    N/A

    clip_image010[4]

    clip_image005[11]

    clip_image010[5]

    Also includes persistence (database access). Check web page for more feature detail

    Makes it possible to create online/multiplayer apps without caring about (or even knowing about) networking. Novel approach via graphical modelling

    Asphyre

    Delphi / Delphi .NET

    clip_image003[6]

    Free

    2D/3D via DirectX

    clip_image010[6]

    clip_image005[12]

    clip_image010[7]

    GUI Editor

    Versions later than v3.1 are only for BDS and Turbo Delphi

    Axiom website

    .NET

    clip_image003[7] clip_image008[3] clip_image013[2]

    LGPL

    3D via OpenGL/DirectX/XNA

    clip_image010[8]

    clip_image010[9]

    clip_image010[10]

    Based on the very popular OGRE rendering engine.

    Baja Engine

    C++/Lua

    clip_image003[8] clip_image013[3]

    Free

    3D via OpenGL

    clip_image005[13]

    clip_image005[14]

    clip_image005[15]clip_image006[4]

    Professional Results, Includes all tools

    Shaders, Shipped a Commercial game, Easy to use, Flexible

    As far as I can see, the site does not indicate source is included with the download (or for that matter, is available) Hard to use art pipeline, no community.

    BigWorld Engine

    C++/Python

    clip_image003[9]clip_image006[5] clip_image008[4]clip_image006[6] clip_image013[4] clip_image015 clip_image017 clip_image019

    Commercial & Indie

    DirectX/9

    clip_image005[16]

    clip_image005[17]

    clip_image005[18] clip_image006[7]

    Professional Results, Includes all tools

    Shaders, Shipped various Commercial games, Easy to use, proven

    Also available with (source-less) Indie versions.

    Blender Game Engine

    Python

    clip_image003[10] clip_image013[5] clip_image008[5] clip_image021

    Free (Open Source)

    3D via OpenGL

    clip_image005[19]

    clip_image005[20] clip_image006[8]

    clip_image005[21] clip_image006[9]

    Physics (including soft bodies) via Bullet, custom written shaders (via GLSL). Can use logic bricks to create basic games without programming experience, or Python for more complex games.

    Included as part of Blender, a fully featured 3D package, so modeling, texturing, etc. all built in.

    Occasionally spotty documentation.

    Blitz3D

    Basic

    clip_image003[11]

    Commercial

    2d/3D via DirectX7

    clip_image005[22]

    clip_image005[23]

    clip_image005[24] clip_image006[10]

    Big community, a lot games

    Easy to start, support BSP, 3DS, better for shareware games

    No OOP, basic syntax

    BlitzMax

    Object Basic

    clip_image003[12] clip_image008[6] clip_image013[6]

    Commercial

    2d via OpenGL

    clip_image005[25]

    clip_image005[26]

    clip_image005[27] clip_image006[11]

    Has many modules (GUI, 3D, Sound, Physics, etc ). Easy to start

    Fast 2D engine, better for casual games(Arcanoids, Puzzles etc.), OOP, LUA Bind

    Has no 3D module

    BlurredEngine

    C++

    clip_image003[13]

    Commercial

    3D via DirectX

    clip_image005[28]

    clip_image005[29]

    clip_image005[30]clip_image006[12]

    incl. Leveleditor and 3D gui components

    Brume Game Engine

    .NET 2.0/3.5 (C#)

    clip_image003[14]

    Free

    3D via DirectX 9/DirectX 10

    clip_image005[31]

    clip_image010[11]

    clip_image010[12]

    Have more modules (GUI, Sound, Physics, Collisions, Animations, Effects (Hardware Shaders), Terrains, etc ). Easy to start

    Easy to use, object oriented, animation system, integrated physics

    C4 Engine

    C++

    clip_image003[15] clip_image013[7] clip_image017[1]

    Commercial

    3D

    clip_image005[32]

    clip_image005[33]

    clip_image005[34]clip_image006[13]

    Voxel terrain, shader editor, more

    Active development, good support, clean architecture

    Chingu

    Ruby

    clip_image003[16] clip_image013[8] clip_image008[7]

    Free

    2D via OpenGL

    clip_image005[35]

    clip_image005[36]

    clip_image010[13]

    Game states, plugginable game logic.. game engine features

    Available on github, 28+ bundled examples.

    Cipher Game Engine

    C/C++

    clip_image003[17]

    Commercial

    3D

    clip_image005[37]

    clip_image005[38]

    clip_image010[14]

    Collision Detection, AI

    ClanLib

    C++

    clip_image003[18] clip_image008[8] clip_image013[9]

    Free (Open Source)

    Accelerated 2D

    clip_image005[39]

    clip_image005[40]

    clip_image010[15]

    Open Source. Excellent lightweight networking

    Cobra (programming language from Squeaky Duck)

    Pascal/Delphi derivative

    clip_image003[19]

    Indie/Commercial

    2D/3D via OpenGL, with an optional separate non-hardware-accelerated 2D mode for compatibility.

    clip_image005[41]

    clip_image005[42]

    clip_image010[16]clip_image006[14]

    Various community supplied extensions (GUIs, Parsers, Virtual Machines)

    Fast 2D graphics

    Somewhat buggy 3D, not-cross platform, somewhat slow bug-fix cycle.

    Cocos2d-x

    C++, Lua

    clip_image023 clip_image025 clip_image015[1] clip_image008[9] clip_image013[10] clip_image003[20]

    Free Open Source (MIT)

    2D via OpenGL

    clip_image005[43]

    clip_image005[44]

    clip_image005[45]clip_image006[15]

    Various community supplied extensions, derived from cocos2d for iPhone to make it multi-platform.

    2D graphics, many commercial games produced using this library.

    Mainly for mobile platforms, other platforms are for development.

    CRM32Pro

    C++

    clip_image003[21] clip_image008[10]

    Closed Source; LGPL announced on site

    2D via SDL/glSDL and optimized MMX blitters

    clip_image005[46]

    clip_image005[47]

    clip_image010[17]

    XML parser, Log, propietary file system to package your resources with full protection and useful EditorDPF to manage them, graphics primitives, cursors, tiles, sprites, fonts, several FX effects, GUI system, accurate timer, MPEG-I video, full support of OGG,modules,WAV and VOC, useful network API andmore...

    Full documentation (english and spanish). Cross-platform. Heavily optimized for each current CPU (MMX and SSE). Available as a DLL or static library(only Win32). EditorDPF, a resources manager. SetupProyect, a customizable config system. Everything is free!

    Crystal Space

    C/C++

    clip_image008[11] clip_image003[22] clip_image013[11]

    Free (LGPL)

    3D via OpenGL

    clip_image005[48]

    clip_image010[18]

    clip_image005[49]clip_image006[16]

    DaBooda Turbo Engine v1.5.4

    VB(COM)/FreeBASIC(VTable)

    clip_image003[23]

    Free (GPL)

    2D(and old school style 3D) via DirectX8

    clip_image005[50]

    clip_image005[51]

    clip_image005[52]

    complete 2D game development environment. Supports VB,VB .Net, FreeBASIC

    AutoMove(ala Zelda1),Sprites,Overlays,Maps,Audio,Network,Counters,

    Key,Joy, FreeBASIC supported through IDispatch, DBFE, or Vtable Documentation in chm, plenty of tutorials and examples..

    Final Build, FreeBASIC build in transition, see DBOS, DBHGE at our site

    Daimonin

    C (server), C++ (client), java (editor)

    clip_image008[12] clip_image003[24] clip_image013[12]

    GPL

    2d/3d via SDL and OGRE3D

    clip_image005[53]

    clip_image005[54]

    clip_image005[55]clip_image006[17]

    complete MMORPG engine

    Delta3D

    C++

    clip_image008[13] clip_image003[25] clip_image013[13]

    Free(LGPL)

    3D via OpenSceneGraph (OpenGL)

    clip_image005[56]

    clip_image005[57]

    clip_image005[58]clip_image006[18]

    ODE Physics, STAGE Game Editor, Much More

    A well-supported open source project. Built upon other open source projects (OSG, ODE, OpenAL, etc.). Great for games, simulations, or other graphical applications. Supports massive terrains. Used by many large scale companies (e.g., Boeing, Lockheed Martin, etc.), educational institutions, and small developers.

    D'Enfent Engine

    C++

    clip_image008[14] clip_image003[26]

    GPL

    2D / 3D via OpenGL

    clip_image010[19]

    clip_image010[20]

    clip_image010[21]

    Lessons and samples for easy start. Shaders are supported.

    DarkbasicPro

    Basic

    clip_image003[27]

    Shareware

    2d/3D via DirectX9

    clip_image005[59]

    clip_image005[60]

    clip_image005[61]clip_image006[19]

    Big community, a lot games

    Easy to start, support BSP, 3DS, better for shareware games

    clip_image010[22] OOP, basic syntax

    DizzyAGE

    C++

    clip_image003[28]

    Free

    2D via DirectX

    clip_image005[62]

    clip_image010[23]

    clip_image005[63] clip_image006[20]

    Tool used to create Dizzy games, in the classic adventure style

    DXGame Engine

    VB6

    clip_image003[29]

    Free

    2D+ via Direct3D

    clip_image005[64]

    clip_image010[24]

    clip_image010[25]

    Automated Sprites, 2D Tile Map (Unlimited Layers), Collision Checking, Explosions, Basic Particle Engine, High Level

    DxIce

    VB6.0 and VB.NET

    clip_image003[30]

    Free (closed source)

    Mostly 2D and some 3D DX9

    clip_image005[65]

    clip_image010[26]

    clip_image010[27]

    Various functions/methods to aid in RAD

    Great for 2D, many helpers for common game routines

    Limited 3D support

    dx_lib32 2.0

    VB 6.0 (also VB.NET)

    clip_image003[31]

    Free

    2D hardware via DirectGraphics (D3D8)

    clip_image005[66]

    clip_image010[28]

    clip_image010[29]

    Draw 2D textures with isometric or caballera perspective in one call, support movie playback (include DivX formats), easy imput handling class, PAK File format support (Quake/Half-Life format), basic Timers counters, support for Timers Events for multithreaing routines (like Timer control of VB but without control interface and instance of this) and more...

    Single light DLL (VB6 Runtime and DirectX API only dependency), simple interface, easy to start, several layers of abstraction, automatic resources management, full documentation of all functions

    clip_image010[30] full OOP interface, ActiveX DLL (need register in the system), all documentation and web site are in spanish (this a problem? maybe... if you aren't

    spanish ;-) )

    DX Studio

    .NET

    clip_image003[32]

    Commercial

    3D via DirectX9

    clip_image005[67]

    clip_image005[68]

    clip_image005[69] clip_image006[21]

    Ageia PhysX, HLSL Shaders, GUI Editor.

    Object-Oriented, Active Development, High-Level Scripting.

    EasyWay Game Engine

    Java

    clip_image003[33] clip_image008[15] clip_image013[14]

    opensource GPL

    2D/3D via OpenGL

    clip_image005[70]

    clip_image010[31]

    clip_image010[32]

    Easily extendible, perfect pixel collision, PathFinding, special effects, automatic engine that don't draw what you don't see, engine anti bug

    very simple: you can write a game in very few lines of code; You can extend simply the game engine with your function

    the API documentation isn't completed yet

    Epee Engine

    C++

    clip_image003[34] clip_image008[16] clip_image013[15]

    zlib/libpng

    2D SDL but 3D planned using OpenGL

    clip_image005[71]

    clip_image010[33]

    clip_image010[34]

    see web site

    Very easy to use and fast rendering

    Engine is still in the early stages

    Entanglar

    Any .Net (VB/C#/C++)

    clip_image003[35]

    Unannounced

    clip_image010[35]

    clip_image010[36]

    clip_image005[72]

    clip_image010[37]

    2D Physics. Stable fixed timeslice timer. Entity management.

    Completely transparent, decoration of properties/methods with attributes makes them automatically synchronised. Remote simulation error prediction. Flexibility to choose any graphics/sound/scripting.

    Alpha build only. No 3D physics yet. Light documentation.

    Entropia Engine

    VB6/C

    clip_image003[36]

    LGPL

    2D using DirectX 8.1

    clip_image005[73]

    clip_image010[38]

    clip_image010[39]

    See Web Site (or the SDK)

    Very easy to use, fast, lots of utilities for a rapid game development, particle engine, sprite engine, map engine and dynamic lights engine (in development but works, see SDK), tiler, console, PAK file format (Quake PAK's), compression , MD5, and much more!

    Web site in Spanish (engine 95 % in English, will fix this soon)

    Esenthel Engine

    C++

    clip_image003[37] clip_image013[16] clip_image015[2]

    Free and Commercial

    3D, DirectX 9/10/11, OpenGL, OpenGL ES

    clip_image005[74]

    clip_image005[75]

    clip_image005[76]

    Many

    Next-Gen Graphics. MMO Capable. Physics. Rich Toolset. Lot of Tutorials. Stable.

    Espresso3D

    Java

    clip_image003[38] clip_image008[17] clip_image013[17]

    Free and Commercial

    3D via LWJGL

    clip_image005[77]

    clip_image010[40]

    clip_image010[41]

    Many

    Ethanon

    AngelScript (made with C++)

    clip_image003[39]

    Free (LGPL)

    Advanced 2D with hardware acceleration

    clip_image005[78]

    clip_image005[79]

    clip_image005[80]

    Many

    Fenix Project (beta)

    language hibrid between Pascal and C

    clip_image003[40] clip_image008[18] clip_image013[18] clip_image021[1] clip_image012[1]

    Open Source

    2D via SDL

    clip_image005[81]

    clip_image005[82]

    clip_image010[42]

    Perfect Pixel collision, path finding routine, music modules and Ogg Vorbis Support, cross plataform, very similitudes with Div Game Studio: compatibility with more of file formats (FPG, MAP, PAL, etc...) and a few compatibility with the syntax and other functions of the Div language

    Very easy syntax, documentation and web site in english and spanish, a complete game of functions, easy for newbies, the evolution of Div Game Studio!

    clip_image010[43] oficial IDE (but existsalternatives), 2D via software, no OPP language, few bugs

    FIFE - the Flexible Isometric Free Engine

    C++, Python

    clip_image003[41] clip_image008[19] clip_image013[19] clip_image027

    Free of charge / open source (LGPL 2.1)

    2D software renderer via SDL, hw-accelerated mode via OpenGL

    clip_image005[83]

    clip_image010[44]

    clip_image005[84] clip_image006[22]

    Ingame console, GUI framework pychan based on guichan, custom XML-based file formats

    One of the few open source 2D isometric game engines available

    Not feature complete at this point but ready to create game with it nevertheless

    FlatRedBall 2.5D

    .NET

    clip_image003[42]

    Free

    3D via DirectX

    clip_image005[85]

    clip_image010[45]

    clip_image010[46]

    Template, Collision Detection, Physics, Skeletons

    G3D

    C++

    clip_image008[20] clip_image003[43] clip_image013[20]

    Free (BSD)

    3D via OpenGL

    clip_image010[47]

    clip_image010[48]

    clip_image010[49]

    G3DRuby

    Ruby

    clip_image003[44] clip_image008[21]

    Free

    3D via OpenGL

    clip_image010[50]

    clip_image010[51]

    clip_image010[52]

    GameCore

    C++

    clip_image003[45] clip_image013[21]

    Commercial, Free trial

    3D

    clip_image005[86]

    clip_image005[87]

    clip_image005[88] clip_image006[23]

    WYSIWYG World Editor provides Terrain editor, FX design, Physics editor, Pathfinding editor, Procedural geometry

    Active development, good support, knowledgeable community

    Game Maker

    Delphi

    clip_image003[46]

    Free and Commercial

    2D/3D

    clip_image005[89]

    clip_image005[90]

    clip_image005[91] clip_image006[24]

    Terrific for making quick 2d tile-based games with easy scripting interface, slow 3D support(via DirectX)

    GameSalad

    No Programming

    clip_image013[22] clip_image015[3]

    Free and Commercial

    2D

    clip_image005[92]

    clip_image010[53]

    clip_image005[93] clip_image006[25]

    Physics, Particles

    Visual system allows for rapid development.

    Mac OS X on Intel only.

    GameStart

    C++

    clip_image003[47] clip_image029

    Commercial, Free trial

    2D/3D

    clip_image005[94]

    clip_image005[95]

    clip_image005[96] clip_image006[26]

    Physics, Particles, Terrain, Character animation

    Comprehensive and fully visual IDE, tailored for developers, designers and artists. Production proofed workflow.

    Genesis3D

    C++

    clip_image003[48]

    Free/Commercial

    3D via DirectX

    GhostEngine

    C++

    clip_image003[49]

    Engine code is Zlib/libPNG-licensed

    3D via OpenGL/DirectX, with DirectX support in the works

    clip_image010[54]

    clip_image005[97]

    clip_image005[98] clip_image006[27]

    As of 5-28-2008, the project has been marked as no longer under development.

    GLBasic

    BASIC

    clip_image003[50] clip_image008[22] clip_image013[23] and other platforms

    Commercial

    2D/3D via OpenGL

    clip_image005[99]

    clip_image005[100]

    clip_image010[55]

    IDE is Windows only, but can compile for other devices included Palm, Android, Windows CE. Simple classes can be used. No chance of source code is usually needed to run on any platform.

    Easy to start, use and can publish programs for AppStore, Palm Catalogue and Android Marketplace

    None

    Glint 3d Engine

    100% lua scriptable, C++ source

    clip_image003[51] clip_image013[24]

    Donation-based licensing. Free version available. Closed source.

    2D/3D via OpenGL/DirectX

    clip_image005[101]

    clip_image005[102]

    clip_image005[103]

    Includes 2D/3D Irrlicht graphics, Bullet physics, 3d OpenAL sound, cryptography, threading, world management, gui controls, gui skins, event management, key-mapping, special fx, dynamic lighting, animation, multi-language support. GUI Editors, Programmer's Reference and more...

    100% scriptable - No install required! No compilers required! Completely extensible and flexible. For apps, sims and games.

    Golden T Game Engine

    Java

    clip_image003[52] clip_image008[23] clip_image013[25]

    Free

    2D via OpenGL

    clip_image005[104]

    Gosu

    C++, Ruby

    clip_image003[53] clip_image013[26] clip_image015[4] clip_image008[24]

    Free (MIT licensed itself, but relies on FMOD or SDL_mixer)

    2D via OpenGL

    clip_image005[105]

    clip_image005[106]

    clip_image010[56]

    Integration with many Ruby libraries

    Modern C++, rather minimalistic

    Grail Adventure Game Engine

    C++, Lua

    clip_image003[54] clip_image008[25] clip_image013[27]

    GPL

    2D via SDL

    clip_image005[107]

    clip_image010[57]

    clip_image005[108]

    clip_image010[58]

    Open & Flexible, write Games in Lua or direct in C++

    Currently still in Development (rewriting from former D-Version known as "indiana")

    HGE (Haaf's Game Engine)HGE at SourceForgeHGE

    C++

    clip_image003[55]

    Open Source (Zlib/libpng license)

    2D via DirectX

    clip_image005[109]

    clip_image010[59]

    clip_image010[60]

    Authoring tools, lightweight

    Easy to start, good engine structure

    No multiplatform

    Horde3D

    C++, C DLL interface

    clip_image003[56]

    Free (LGPL)

    3D via OpenGL

    clip_image010[61]

    clip_image010[62]

    clip_image005[110]

    Shader based design, skeletal animation, animation blending, morph targets, post processing effects like HDR or DOF, COLLADA support

    Lightweight next-generation engine with clean design

    id Tech 1

    C

    clip_image003[57] clip_image008[26]

    Free (GPL)

    2.5D, fan-made enhancements: 3D

    clip_image005[111]

    clip_image005[112]

    clip_image010[63]

    C++ support in some fan-made versions.

    Used to make Doom WAD's, Ports and Mods. Large active community

    Official version technically outdated/limited, fan-made versions still maintained and updated

    id Tech 2

    C

    clip_image003[58] clip_image008[27]

    Free (GPL) or Commercial without GPL limits

    3D

    clip_image005[113]

    clip_image005[114]

    clip_image010[64]

    C++ support in some fan-made versions.

    Allows designing of Quake II Mods (with Quake IISource)

    Technically outdated, may not work on later Windows + Linux machines.

    id Tech 3

    C

    clip_image003[59] clip_image008[28]

    Free (GPL) or Commercial without GPL limits

    3D

    clip_image005[115]

    clip_image005[116]

    clip_image010[65]

    C++ support in some fan-made versions. Last C-based id Engine that works on all Windows and Linux machines.

    Still used today

    Relatively weak graphics compared to new Engines

    id Tech 4

    C++

    clip_image003[60] clip_image008[29]

    Free (GPL), previously commercial

    3D

    clip_image005[117]

    clip_image005[118]

    clip_image010[66]

    First intended C++ id Engine

    Full realtime shadows, XBOX Support (With XBOX License)

    Graphics based on outdated stencil shadows (compared to modern next-gen games)

    Ignifuga

    Python/Cython

    clip_image003[61] clip_image008[30] clip_image013[28] clip_image023[1] clip_image015[5]

    Open Source (modified BSD) / Commercial license req'd for splash screen removal

    2D via OpenGL or Direct3D 9 via SDL

    clip_image010[67]

    clip_image010[68]

    clip_image005[119] clip_image006[28]

    Component based, data driven, sprites, fonts, parallax scrolling

    Dynamic development and fully static binary only deployment to targets. No hassle building and packaging for all targets using the Schafer tool.

    Currently in alpha stage of development, though actively developed.

    ika

    C++

    clip_image003[62] clip_image008[31]

    Free (GPL)

    2D via OpenGL

    clip_image005[120]

    clip_image010[69]

    clip_image005[121] clip_image006[29]

    very low overhead...

    Irmo

    C

    clip_image008[32]

    Free

    clip_image005[122]

    clip_image005[123] clip_image006[30]

    Only a networking engine.

    Irrlicht

    C++/.NET

    clip_image003[63] clip_image008[33] clip_image013[29]

    Free (zlib/pnglib)

    3D via DirectX(8,9), OpenGL or various software renderers

    clip_image010[70]

    clip_image010[71]

    clip_image005[124] clip_image006[31]

    Collision Detection, HDR, PARALLAX

    Big Community, a lot examples and tutorials

    Active development - Stable

    IwGame Engine

    C++

    clip_image003[64] clip_image013[30] clip_image015[6] clip_image023[2] clip_image006[32]

    Free

    2D

    clip_image005[125]

    clip_image005[126]

    clip_image010[72]

    Built on top of the Marmalade SDK. Accelerometer, compass, multi-touch, http resource loading, unified ad API, auto screen size and aspect management.

    Unified animating Ad API supporting 12 different ad providers for free game developers that want to maximise their games revenue potential. Fully documented and regularly updated.

    Jad Engine - C# + MDX Game Engine

    C#

    clip_image003[65]

    LGPL

    3D via Managed DirectX

    clip_image005[127]

    clip_image010[73]

    clip_image010[74]

    Focused to graphics cards that support shaders 2.0 or better, It uses Newton Physics Engine to generate realistic movements and responses, HDR support (the graphic card must support floating point blending), FirstPerson and SelfDriven (exported from 3D Studio Max) cameras support, Animation Skeletal animation using channels, Imports directly MD5 files..., Postproduction system integrated in the engine, AI Engine: Genetic Programming Framework

    Very more easy and intuitive interface, documentation and support are in english, a simple DLL

    clip_image010[75] full documentation

    Jamagic 1.2

    Jamascript

    clip_image003[66]

    Commercial(Withdrawn from sale)

    3D

    clip_image005[128]

    clip_image005[129]

    clip_image005[130]

    Inbuilt editors

    Easy to Learn, online games like flash

    No longer supported

    JawsJS 2D Engine

    Javascript

    Browsers

    LGPL

    2D

    clip_image005[131]

    clip_image010[76]

    clip_image010[77]

    Supports both Canvas and HTML-based sprites

    easy to get started, lots of examples

    Needs a fairly new browser

    JEngine SSE

    C++

    clip_image003[67] clip_image008[34]

    Free (GPL)

    2D via OpenGL

    clip_image005[132]

    clip_image005[133]

    clip_image005[134]clip_image006[33]

    Collision detection,Cg&GLS effects,GUI,etc. Contains full 2D open source framework with editor.

    Jet3D

    C/C++

    clip_image003[68]

    Free

    3D via DirectX

    clip_image005[135]

    JGame

    Java

    clip_image003[69] clip_image008[35] clip_image013[31]

    Free (BSD)

    2D

    clip_image005[136]

    clip_image010[78]

    clip_image010[79]

    jMonkey Engine

    Java

    clip_image003[70] clip_image008[36] clip_image013[32]

    Free (BSD)

    3D via LWJGL

    clip_image005[137]

    clip_image005[138]

    clip_image005[139] clip_image006[34]

    A Java scene graph based 3D game engine. See the latest release notes

    Joge

    Java

    clip_image003[71] clip_image008[37] clip_image013[33]

    Free (Creative Commons License)

    2D via LWJGL

    clip_image005[140]

    clip_image010[80]

    clip_image010[81]

    JOGRE Engine

    Java

    clip_image003[72] clip_image008[38] clip_image013[34]

    Free (BSD)

    2D

    ?

    clip_image010[82]

    clip_image010[83]

    Java Online Gaming Real-time Engine.

    Lavgine

    Engine in C++, Games in Lua

    clip_image003[73]

    Free (non-commercial), Commercial (15% from profits), Closed Source

    Hardware accelerated 2D

    clip_image005[141]

    clip_image005[142]

    clip_image005[143] clip_image006[35]

    LiveData Manager to swap data on change, Box2D-based physics, 3D Sound based on XACT (Content-driven API), Game Programming in LuaScript (optional: encrypted scripts), Achievement System, Networking, Unicode support for bitmap fonts, Profile system for saving in-game variables

    Still evolving. Last update: 2011-07, developed by ONE person (consequence, integrity, the same API and quality of code :P)

    Alpha phase (2011-07), lack of tools (in plans), developed by ONE person

    Leadwerks 3d engine

    C++/C#/Delphi/BlitzMax

    clip_image003[74]

    Commercial

    3D via OpenGL

    clip_image005[144]

    clip_image005[145]

    clip_image005[146] clip_image006[36]

    Lightfeather 3d engine

    C++

    clip_image003[75] clip_image008[39] clip_image013[35]

    Free (zlib/libpng)

    3D via OpenGL

    clip_image010[84]

    clip_image005[147]

    clip_image010[85]

    GLSL and Cg shaders, HDR rendering, MRT , Portals, occlusion culling, PVS, Skeletal and Morphing Animation, Exporter for Blender to lfm format, Post-Processing Framework, Paging terrain with splatting (includes editor + generator), Built-in GUI, Particle system editor|more..

    LÖVE

    Lua

    clip_image003[76] clip_image013[36] clip_image008[40]

    zlib/libpng

    2D via OpenGL

    clip_image005[148]

    clip_image005[149]

    clip_image005[150]

    Box2D wrapper library included out-of-box.

    Maker3D

    Custom

    clip_image003[77] clip_image008[41]

    Commercial

    3D

    clip_image005[151]

    clip_image010[86]

    clip_image005[152] clip_image006[37]

    WYSIWYG editor, Crossplatform

    RPG (role playing game) designer, character generation, battle system, easy to Learn, team management

    Moai

    C++ for the engine, Luafor the games

    clip_image003[78] clip_image013[37] clip_image015[7] clip_image023[3]Google Native Client

    Open Source (CPAL)

    2D via OpenGL (WIP 3D)

    clip_image005[153]

    clip_image005[154]

    clip_image005[155] clip_image006[38]

    Physics (Box2D or Chipmunk), animation, analytics, monetization.

    Good performance. Developed by a professional team. Cloud services.

    MonoGame

    C#

    clip_image003[79] clip_image008[42] clip_image013[38] clip_image015[8] clip_image023[4]

    Free (Open Source)

    2D (3D is planned in 2012)

    clip_image005[156]

    clip_image005[157]

    clip_image010[87]

    Based on Mono

    Open source XNA implementation

    Multimedia Fusion 2

    Custom - none scripting

    clip_image003[80]

    Commercial

    2D

    clip_image005[158]

    clip_image005[159]

    clip_image005[160] clip_image006[39]

    ActiveX, Dll, many plug-ins, movement extensions

    Easy to Learn, a favourite with younger developers, online games like flash

    neabEngine

    PHP

    clip_image003[81] clip_image008[43]

    Free / Commercial

    2D (AJAX)

    clip_image010[88]

    clip_image005[161]

    clip_image005[162]

    Comes with the full source code, allows to add/edit modules.

    NeL (alt:OpenNel)

    C/C++

    clip_image003[82] clip_image008[44]

    Free/Commercial

    3D via DirectX or OpenGL

    clip_image005[163]

    clip_image005[164]

    CEGUI Integration

    NemoX 3D Engine

    VB/Delphi/.NET

    clip_image003[83]

    Free

    3D via DirectX

    clip_image005[165]

    clip_image005[166]

    clip_image005[167]

    NeoAxis Game Engine

    API: C#/.NET, Internally: C++

    clip_image003[84] clip_image013[39] clip_image008[45]

    Free/Commercial

    3D via DirectX or OpenGL

    clip_image005[168]

    clip_image005[169]

    clip_image005[170]

    Game Demo, GUI Editor, Map Editor, Resource Editor (Mesh, Particles, etc...), ODE and PhysX by AGEA Support, and Documentation

    You can purchase the source code of the engine.

    NeoEngine

    C++

    clip_image003[85] clip_image008[46]

    Free (MPL)

    3D via DirectX or OpenGL

    clip_image005[171]

    clip_image005[172]

    clip_image005[173] clip_image006[40]

    NetGore

    C#

    clip_image003[86] clip_image008[47] clip_image013[40]

    Free (Open Source)

    2D (top-down and platformer) via SFML (OpenGL)

    clip_image005[174]

    clip_image005[175]

    clip_image005[176]

    Open source, multiplayer (MMORPG) support, very active development

    Novashell Game Creation

    Lua

    clip_image003[87] clip_image008[48] clip_image013[41]

    zlib/libpng

    ClanLib (OpenGL)

    clip_image005[177] clip_image006[41]

    clip_image010[89]

    clip_image005[178] clip_image006[42]

    Fast Game Creation with Lua

    sector based partitioning, easy editing files, level editor

    Beta

    OGE - Open Game Engine

    C++

    clip_image003[88] clip_image008[49]

    Free (LGPL) / Commercial

    3D (OGRE hence DX + OpenGL)

    clip_image005[179] clip_image006[43]

    clip_image010[90]

    clip_image005[180] clip_image006[44]

    Multithread and pluggable design, MyGUI, Physics (Bullet), Unicode, OGEd - Game Editor

    Multithread, Plugin-based, Clean OO, Early stage of development

    Early stage of development

    OGRE

    C++

    clip_image003[89] clip_image008[50] clip_image013[42]

    Free (LGPL) / Commercial

    3D via DirectX or OpenGL

    clip_image010[91]

    clip_image010[92]

    clip_image010[93]

    Super 3D Engine, Support All HighEnd 3D Technologies, Plugin structure

    Big Community, A lot examples and tutorials, made severals big games (like as air simulation, 3d adventure, 3d action), Open Source

    too big source code

    ORE

    VB6

    clip_image003[90]

    Free

    2d via DirectX7 / DirectX8

    clip_image005[181]

    clip_image005[182]

    clip_image005[183]

    Orx: Portable Game Engine

    C/C++

    clip_image003[91] clip_image008[51] clip_image013[43] clip_image015[9]

    Free (zlib)

    2.5D, hardware accelerated

    clip_image005[184] clip_image006[45]

    clip_image010[94]

    clip_image010[95]

    Data driven. Lightweight. Portable. Very easy to use.

    Extended unique features (animation graph, hierarchical config files, independent clocks, hierarchical objects, differential scrolling, ...).

    Ovorp Engine

    .NET

    clip_image003[92]

    Free

    2D via DirectX

    clip_image005[185]

    Panda3D

    C++, Python

    clip_image003[93] clip_image008[52] clip_image013[44] clip_image015[10]

    Free

    3D via OpenGL, DirectX or TinyGL

    clip_image005[186] clip_image006[46]

    clip_image005[187]

    clip_image005[188] clip_image006[47]

    Free models, documentation, simple installation

    Used by Disney to make ToonTown, easy learning, very stable

    PixelLight

    C++

    clip_image003[94] clip_image008[53] clip_image023[5]

    LGPL

    3D via OpenGL (+ experimental 3D via DirectX9)

    clip_image005[189] clip_image006[48]

    clip_image005[190]

    clip_image005[191] clip_image006[49]

    See official feature list

    PLib

    C++

    clip_image008[54] clip_image003[95] clip_image013[45]

    Free (LGPL)

    2D and 3D via OpenGL

    clip_image005[192]

    clip_image005[193]

    clip_image005[194]

    Playground SDK

    C++, Lua

    clip_image003[96] clip_image013[46]

    Free

    2d/3d via DirectX/OpenGL on Windows/Mac

    clip_image005[195]

    clip_image010[96]

    clip_image005[196] clip_image006[50]

    Animation editor; dialog editor; particle editor; ultra-flexible particle system; 2d sprite system; dynamic texture atlas support; flat file support; background file reading support; small footprint.

    Used by PlayFirst and many other developers to write over 100 published causal games. Best-in-class i18n. Excellent documentation and support in the forums.

    No game editor (yet; one is planned).

    PVLE game engine

    C++

    clip_image003[97] clip_image008[55] clip_image013[47]

    GPL / Proprietary (Commercial)

    2D/3D via OpenSceneGraph (OpenGL)

    clip_image010[97]

    clip_image010[98]

    clip_image010[99]

    Physics via ODE, object oriented

    Small and easy game engine. Uses the most existing code possible.

    Very young and still alpha

    Popcap Framework

    C++

    clip_image003[98]

    Free

    2D

    clip_image005[197]

    clip_image010[100]

    clip_image010[101]

    Super Game Engine for developing super games like as Zuma

    have great game ZUMA

    Not 3D

    PowerRender

    C++

    clip_image003[99] clip_image019[1]

    Commercial

    3D via DirectX

    clip_image005[198]

    clip_image010[102]

    clip_image005[199] clip_image006[51]

    Physics, Collision Detection, HDR

    Easy to start, flexible engine

    Bad working with shadowing

    PTK Engine

    C++

    clip_image003[100] clip_image013[48]

    Free and Commercial

    2D

    clip_image005[200]

    clip_image010[103]

    clip_image010[104]

    Font, TTF, Spline, Tar files

    Lightweight and Crossplatform

    PureBasic

    Basic

    clip_image013[49] clip_image008[56] clip_image003[101]

    Commercial

    PySoy

    Python

    clip_image008[57] clip_image013[50] clip_image003[102]

    Free (GPLv3)

    3D via OpenGL

    clip_image005[201] clip_image006[52]

    clip_image005[202]

    clip_image005[203]

    Integrated Physics

    No proprietary dependencies

    Still in Beta (lacks features)

    Quake Engine

    C

    clip_image003[103] clip_image008[58] clip_image013[51]

    GPL, Commercial

    Software, OpenGL

    clip_image005[204]

    clip_image005[205]

    clip_image005[206] clip_image006[53]

    Quake II Engine

    C

    clip_image003[104] clip_image008[59] clip_image013[52]

    GPL, Commercial

    OpenGL

    clip_image005[207]

    clip_image005[208]

    Quake III Arena Engine

    C

    clip_image003[105] clip_image008[60] clip_image013[53]

    GPL, Commercial

    OpenGL

    clip_image005[209]

    clip_image005[210]

    Raydium 3D

    C

    clip_image003[106] clip_image008[61]

    Free (GPL)

    3D via OpenGL

    clip_image005[211] clip_image006[54]

    clip_image005[212]

    clip_image005[213] clip_image006[55]

    Physics via ODE

    Ray Game Designer 2

    None needed

    clip_image003[107]

    Free

    3D via OpenGL or Direct3D

    clip_image005[214]

    clip_image010[105]

    clip_image005[215]

    Collision Detection, Translucency, Lighting

    Requires no programming, very easy to use, includes most needed tools

    Very limited gameplay options, outdated graphics engine, very small community

    Reality Factory

    None needed

    clip_image003[108]

    3D viaGenesis3D(DirectX)

    clip_image005[216]

    clip_image005[217]

    clip_image005[218]

    RealmForge Game Engine

    C# (.NET)

    3D via Axiom(OpenGL)

    clip_image005[219]

    clip_image005[220]

    clip_image005[221]

    RetinaX

    Completelty .NET 2.0 (C#). No wrapped C++ Libraries.

    Free (BSD)

    3D via Managed DirectX

    clip_image005[222]

    clip_image010[106]

    clip_image010[107]

    User Interface

    Easy to start programming DirectX. Framework is well structured and you can modify it to your liking.

    RPG Maker 2003

    C/Delphi

    clip_image003[109]

    Shareware

    2D

    clip_image005[223] clip_image006[56]

    clip_image005[224]

    clip_image005[225] clip_image006[57]

    Level Editor

    Easy to use

    Not open source

    RPG Maker XP

    C/Delphi

    clip_image003[110]

    Shareware

    2D

    clip_image005[226] clip_image006[58]

    clip_image005[227]

    clip_image005[228] clip_image006[59]

    Level Editor

    Easy to use

    clip_image010[108]t open source

    Saq2D

    C#

    clip_image003[111]

    Free

    2D engine via XNA

    clip_image010[109]

    clip_image010[110]

    clip_image010[111]

    scge

    C++ / Python

    clip_image003[112] clip_image013[54] clip_image008[62]

    Free (Public Domain)

    2D and 3D via OpenGL

    clip_image005[229] clip_image006[60]

    clip_image005[230] clip_image006[61]

    clip_image005[231] clip_image006[62]

    Gerneral Purpose Engine

    Easy to use and versatile

    Slot Constructor

    Lua, C

    clip_image003[113] clip_image008[63]

    Commercial

    2D and 3D via OpenGL

    clip_image005[232]

    clip_image005[233] clip_image006[63]

    clip_image005[234] clip_image006[64]

    Specially designed for casino and amusement game machines. Deploy to gaming boards and PC.

    Extremely easy to use, has own IDE and other GUI tools.

    3D is very limited.

    SLUDGE

    C++

    clip_image003[114] clip_image013[55] clip_image008[64]

    Free (LGPL)

    2D via OpenGL

    clip_image005[235] clip_image006[65]

    clip_image010[112]

    clip_image005[236] clip_image006[66]

    Engine for graphic adventures

    Easy to use

    Spring RTS Engine

    C++/Lua

    clip_image008[65] clip_image003[115] clip_image013[56]

    GPL2

    3D via OpenGL

    clip_image005[237] clip_image006[67]

    clip_image005[238]

    clip_image005[239] clip_image006[68]

    Large User Community

    SoftPixel Engine

    C++

    clip_image003[116]

    Free (zlib/libpng)

    3D via OpenGL 2.0

    clip_image005[240] clip_image006[69]

    clip_image005[241] clip_image006[70]

    clip_image005[242] clip_image006[71]

    Collision Detection, Shader (GLSL), very simple

    Very easy like BASIC languages but powerfull like C++ & OpenGL

    Active development. Some unfinished parts

    Source Engine

    C++

    clip_image003[117] clip_image008[66]clip_image006[72]

    Commercial/Free

    Direct3D

    clip_image005[243]

    clip_image005[244]

    clip_image005[245] clip_image006[73]

    Havok Physics, Valve Faceposer Technology, VGUI, HDR, Steam Community,SDk

    Sphere RPG Engine

    Javascript

    clip_image003[118] clip_image008[67] clip_image013[57]

    GPL

    2D via software or hardware (OpenGL or DirectX) rendering

    clip_image005[246]

    clip_image005[247]

    clip_image005[248] clip_image006[74]

    Map editor, tile editor, image editor, imports RPG Maker resources

    Very good map/tile engine, cross-platform, imports many resources, and fully featured to make your own SNES/Genesis style game.

    The Nebula Device 2

    C++

    clip_image003[119]

    Free

    3D via DirectX

    clip_image005[249]

    clip_image005[250]

    clip_image005[251]

    Thousand ParsecFramework

    Python, C++, others

    clip_image003[120] clip_image008[68] clip_image013[58]

    Free (GPL)

    2D/3D

    clip_image010[113]

    clip_image005[252]

    clip_image005[253]

    Framework for online turn based space strategy games

    TNT Basic

    Basic

    clip_image013[59]

    Free (GPL)

    2D

    clip_image005[254]

    clip_image010[114]

    clip_image010[115]

    Torque

    C++

    clip_image003[121] clip_image008[69] clip_image013[60]

    Commercial

    3D via OpenGL

    clip_image005[255] clip_image006[75]

    clip_image005[256]

    clip_image005[257] clip_image006[76]

    Mission Editor, Terrain Editor, Mac and Linux Support, WYSIWYG GUI Editor, Particle Engine, Theora Video, Multiple Language Support

    Source Code Included, Large Community, Many 3D modeling exporters

    Buggy, slow, outdated

    Torque2D

    C++

    clip_image003[122] clip_image008[70] clip_image013[61]

    Commercial

    2D

    clip_image005[258] clip_image006[77]

    clip_image005[259]

    clip_image005[260] clip_image006[78]

    Truevision3D

    VB/Delphi/C++/.NET

    clip_image003[123]

    Free for learning/Commercial

    3D via DirectX

    clip_image005[261] clip_image006[79]

    clip_image005[262]

    clip_image005[263] clip_image006[80]

    Physics, Plugins for popular modeling packages, Active user base, Normal Mapping, Relief Mapping, and complex shaders

    UnrealEngine2 / 2X / 3

    C++

    clip_image003[124] clip_image008[71] clip_image013[62] clip_image017[2] clip_image019[2]

    Commercial

    3D

    clip_image005[264]

    clip_image005[265]

    clip_image005[266] clip_image006[81]

    Physics, HDR (UE3)

    high cost

    UnrealEngine2 Runtime

    C++

    clip_image003[125] clip_image008[72] clip_image013[63] clip_image017[3],clip_image019[3]

    Non-Commercial / Educational

    3D

    clip_image005[267]

    clip_image005[268]

    clip_image005[269] clip_image006[82]

    Need to be a 'serious developer'. Still pricey. No source code.

    Unigine

    C++

    clip_image003[126] clip_image008[73] clip_image013[64] clip_image017[4] clip_image023[6] clip_image015[11]

    Commercial

    3D

    clip_image005[270]

    clip_image005[271]

    clip_image005[272] clip_image006[83]

    DX9/DX10/DX11/OpenGL/OpenGL ES render, shaders 5.0, hardware tessellation, stereo 3D, physics, pathfinding, sound, GUI

    Great 3D Engine, image quality like as CryEngine and Unreal, small cost, more tools

    Unity

    C++

    clip_image003[127] clip_image029[1], Browsers

    Free/Commercial

    3D via DirectX or OpenGL

    clip_image005[273]

    clip_image005[274]

    clip_image005[275] clip_image006[84]

    Ageia PhysX, terrain engine, extensible shaders, JIT compiled scripts, collaboration tools, friendly community, most file formats supported

    Smooth workflows, lots of powerful tools, complete documentation

    Advanced features cost more, source code is separate license

    Verge

    Lua or VergeC

    clip_image003[128] clip_image013[65] clip_image008[74]

    Free (BSD license)

    Software 2D

    clip_image005[276]

    clip_image005[277]

    clip_image005[278]

    Friendly community, tile-based map editor tool, fully scriptable game

    Extremely easy to rapidly prototype something, simple-to-use software graphics.

    Requires some knowledge of scripting. Does not have hardware accelerated graphics.

    vbGORE

    VB6

    clip_image003[129]

    Free (Open Source)

    2D via 3D

    clip_image005[279]

    clip_image005[280]

    clip_image010[116]

    Designed towards ORPG and MMORPG design

    [Valve]

    Python

    clip_image003[130] clip_image008[75]

    commercial

    2D/3D via DirectX and OpenGL

    clip_image005[281]

    clip_image010[117]

    clip_image005[282] clip_image006[85]

    Many

    Vision Game Engine

    C++

    clip_image003[131] clip_image019[4] clip_image017[5] clip_image029[2]

    Commercial

    DirectX 9-11

    clip_image005[283]

    clip_image005[284]

    clip_image005[285] clip_image006[86]

    Supports XBLA, PSN and WiiWare. Includes FMOD and RakNet free-of-charge. Includes 20+ integrations to other 3rd party middleware (physics, AI, weather, vegetation, audio, asset management and more)

    Optimized for many platforms. Highly flexible workflow. Modular architecture. Flexible pricing. Excellent support.

    Not as well known. Community is small, but growing.

    Visual3D Game Engine

    C# (.NET)

    clip_image003[132] clip_image019[5]

    Commercial, Free for Open Source and Educational Use

    3D via XNA

    clip_image005[286]

    clip_image005[287]

    clip_image005[288] clip_image006[87]

    All-in-one Game Development Toolset, HDR, Per-pixel, Parallax, Dynamic Soft Shadows, God Rays, SSAO*), Entity/Model/Material Editor, Particle Editor (Explosions, Volumetrics) , Advanced Physics (Rag Dolls, Vehicles), Terrain Editor (Procedural Generation, Massive Full-Globe Terrain, Land Cover Painting, Geodata), AI and Pathfinding, Multiplayer Networking, Cinematics/Path/Road Editors, Real-time In-Game Scene/Mission Editing, Script/Conversation Editor, 3D Audio, Day-Night Cycle, Free Starter Kits/Asset Libraries, C# Shaders, UI Editor, Web Deployment*, Collaborative Editing* (* coming soon)

    tIDE map editor / xTile engine

    C# / XNA

    clip_image003[133] clip_image019[6]

    Free

    2D Tile Map Editor and Engine

    clip_image010[118]

    clip_image010[119]

    clip_image010[120]

    WYSIWYG parallax layer editing, animated tiles, custom properties,

    plugin support, XNA-ready content pipeline extensions

    YAKE Engine

    C++

    clip_image003[134] clip_image008[76]

    Free

    3D via OGRE(OpenGL), Direct3D9

    clip_image005[289]:clip_image006[88]

    clip_image005[290]

    clip_image005[291] clip_image006[89]

    GUI via CEGUI, physics viaODE

    Yage

    D

    clip_image003[135] clip_image008[77]

    Free (LGPL)

    3D via OpenGL

    clip_image005[292] clip_image006[90]

    clip_image010[121]

    clip_image010[122]

    YVision

    .NET(C#)

    clip_image003[136] clip_image013[66], Silverlight 5, Windows Phone 7

    Commercial (Free)

    Axiom

    clip_image005[293]

    clip_image010[123]

    clip_image005[294] clip_image006[91]

    Integrated physics(BulletXNA), image processing(OpenCV), augmented-reality(SLARToolkit)), multi-threading, steering behaviors.

    Zak Engine

    C++

    clip_image003[137]

    Free

    2D via DirectX 8.1 and 9.0

    clip_image005[295]

    clip_image005[296]

    clip_image005[297] clip_image006[92]

    Tiles Maps (AnaConda Map Editor), Sprites, Particle Systems, Bitmap Fonts

    Very stable, easy to use, fast games development

    ZFX Community Engine

    C++

    clip_image003[138] clip_image008[78] clip_image027[1]

    Free (LGPL)

    3D via DirectX and OpenGL

    clip_image005[298]

    clip_image005[299]

    clip_image005[300] clip_image006[93]

    Edge2d Engine

    C++

    clip_image003[139] clip_image008[79]

    Open Source

    Library independent(both DirectX and OpenGL etc

    clip_image005[301]

    clip_image010[124]

    clip_image010[125]

    very object-oriented and plugin-based, you can create your own graphics plugin without modified base library

    Phoenix Engine

    C#

    clip_image003[140]

    Beta

    SDL.NET

    clip_image005[302]

    clip_image005[303]

    clip_image010[126]

    IronPython

    Map Editor, Sprite, Plugin system, e.t.c

    Weaver

    C

    clip_image008[80]

    Free (GPL)

    2D

    clip_image005[304]

    clip_image010[127]

    clip_image010[128]

    Ogg Vorbis support, complete framework, collision detection

    Easy to start, learn and use. Fast 2D engine. Self-contained system.

    External Links

    § 3D Engines List

    § DevMaster.Net 3D Engine Database

    § Jeux Infinis Engine Database (french)

  • 相关阅读:
    vue-cli 安装一直失败
    如果不存在公缀,返回空字符串
    .sh文件格式问题dos转linux或unix
    Kettle串联多个Spark任务
    云效自动化部署+部署包备份
    云效分支管理
    云效IDE综合插件Alibaba Cloud Toolkit
    流水线自动化部署-中转部署-目标机器不联网情况下应用
    云效流水线自动化部署
    云效流水线自动发布到Maven仓
  • 原文地址:https://www.cnblogs.com/pulas/p/2459354.html
Copyright © 2020-2023  润新知