Last December Miguel de Icaza blogged about a cool, cross platform, light weight 3D game engine that's very C# and friendly...
[Post Copied in Full]
Building 3D experiences and games using a high-level framework that works across all of the major platforms is now as easy as installing a single NuGet package.
UrhoSharp brings the Urho3D game engine to C# and F# developers targeting Android, iOS, Mac, tvOS, and Windows. It delivers scene management, a component-based architecture, actions, animations, 3D and 2D physics, audio, mesh navigation, and networking richly blended into .NET with all of the idioms that you’ve come to know and love.
UrhoSharp is a lightweight Game Engine suitable for using with C# and F# to create games that run on Android, iOS, Mac, Windows and Unix. The game engine is available as a portable class library, allowing your game code to be written once and shared across all platforms. UrhoSharp is powered by Urho3D (http://urho3d.github.io/), a game engine that has been under development for more than a decade. All the samples from Urho3D have been ported to C# to help you get started:
Among the features of the Urho3D you will find:
- Direct3D9, Direct3D11, OpenGL 2.0 or 3.2 or OpenGL ES 2.0 rendering
- HLSL or GLSL shaders + caching of HLSL bytecode
- Configurable rendering pipeline. Default implementations for forward, light pre-pass and deferred rendering
- Component based scene model
- Skeletal (with hardware skinning), vertex morph and node animation
- Automatic instancing on SM3 capable hardware
- Point, spot and directional lights
- Shadow mapping for all light types; cascaded shadow maps for directional lights
- Particle rendering
- Geomipmapped terrain
- Static and skinned decals
- Auxiliary view rendering (reflections etc.)
- Geometry, material & animation LOD
- Software rasterized occlusion culling
- HDR renderingv1.31
- 2D sprites and particles that integrate into the 3D scenev1.31
- Task-based multithreading
- Hierarchical performance profiler
- Scene and object load/save in binary and XML format
- Keyframe animation of object attributes
- Background loading of resources
- Keyboard, mouse, joystick and touch input (if available)
- Physics using Bullet
- 2D physics using Box2D
- Networking using kNet + possibility to make HTTP requests
- Pathfinding and crowd simulation using Recast/Detour
- Image loading using stb_image + DDS / KTX / PVR compressed texture support
- 2D and “3D” audio playback, Ogg Vorbis support using stb_vorbis + WAV format support
- TrueType font rendering using FreeType, AngelCode bitmap fonts are also supported
- Unicode string support
- Inbuilt UI system
- Scene editor and UI-layout editor implemented in script with undo & redo capabilities
- Model/scene/animation/material import from formats supported by Open Asset Import Library
- Alternative model/animation import from OGRE mesh.xml and skeleton.xml files
UrhoSharp is a cross-platform high-level 3D and 2D engine that can be used to create animated 3D and 2D scenes for your applications using geometries, materials, lights and cameras.
UrhoSharp is distributed as a NuGet package that can be installed on either Visual Studio or Xamarin Studio on Mac or Windows and can be used to target any of the following platforms: Android, MacOS, iOS, tvOS and Windows.
This article provides a high-level overview of UrhoSharp and its capabilities for 3D visualization and for use in simple 3D games.
In this document we describe the core concepts of UrhoSharp that you would use to build a game or create a 3D visualization for your application.
UrhoSharp is a powerful 3D Game Engine for Xamarin and .NET developers. It is similar in spirit to Apple’s SceneKit and SpriteKit and include physics, navigation, networking and much more while still being cross platform.
It is a .NET binding to the Urho3D engine and allows developers to write cross platform code that can target Android, iOS, Windows and Mac with the same codebase and can render to both OpenGL and Direct3D systems.
UrhoSharp is a game engine with a lot of functionality out of the box:
- Powerful 3D graphic rendering
- Physics simulation (using the Bullet library)
- Scene handling
- Await/Async support
- Friendly Actions API
- 2D integration into 3D scenes
- Font rendering with FreeType
- Client and server networking capabilities
- Import a wide range of assets (with Open Assets Library)
- Navigation mesh and pathfinding (using Recast/Detour)
- Convex hull generation for collision detection (using StanHull)
- Audio playback (with libvorbis)
UrhoSharp is conveniently distributed as a NuGet package and it can be added to your C# or F# projects that target Windows, Mac, Android or iOS. The NuGet comes with both the libraries required to run your program, as well as the basic assets (CoreData) used by the engine.
Urho as a Portable Class Library
The Urho package can be consumed either from a platform-specific project, or from a Portable Class Library project, allowing you to reuse all of your code across all platforms. This means that all you would have to do on each platform is to write your platform specific entry point, and then transfer control to your shared game code.
You can get a taste for the capabilities of Urho by opening in either Xamarin Studio or Visual Studio the Sample solution from:
... [Whole Article]
This directory contains various samples for the UrhoSharp engine and they can be compiled for Android or iOS, or can be executed on Windows and Mac with the published NuGet package.
FeatureSamplessolution showcases 40 independent UrhoSharp features, each one showcasing a particular element of the framework and runs on all supported platforms.
SamplyGamedirectory contains a more complete game, it is a sample inspired by the gameplay and artwork of ShootySkies and shows a more complete game in action, showing how to load assets, write game code and structure a game. It is our first game build with this, so be kind.
Both solutions are structured to have their cross platform code written in the
Coredirectory, where we build a portable class library. While we have taken the approach of using Portable Class Libraries, you can also used Shared Projects.
The structure of each solution is this:
Assets: Contains the shared assets that are used for the various samples.
Core: Contains the various samples, one for each feature that is being showcased and it happens to be a Portable Class Library project, so it can be reused as-is across all supported platforms.
iOS: Contains the iOS launcher.
Android: Contains the Android launcher.
Mac: Contains the Mac launcher (but works on Windows too).
WPF: Contains the Windows launcher based on WPF.
WinForms: Contains the Mac launcher based on WinForms.
To build the samples:
Some screenshots (you can find more in each directory of FeatureSamples/Core):