SoftPixel Engine

Home | Forum | MediaWiki | HLC Games | API Docu

Welcome to the SoftPixel Engine

Welcome to the homepage of the SoftPixel Engine, a high-level real-time 3d engine written in C++ for Windows and Linux.
It is designed for writing 2d- and 3d games and graphics applications. You will see the performance and the big collection of functions for rendering 3d worlds and drawing primitives or complex 2d objects.

There is a wrapper for: C#, VisualBasic, BlitzBasic, BlitzMax, PureBasic, ObjectPascal.

Look at the features to see the performance!

(additional developers, modelers or 3D artists desired)

News (more...)

9th January 2012:

The SoftPixel Engine 3.1 has been released (over 106,500 LoC)

It's a long time ago I released the last version of the SoftPixel Engine. But the wait was worth it. There are a lot of great new features and many improvements were made.

Finally the SoftPixel Engine got an official sandbox editor with a scene file format the engine can load easily: The SoftPixel Sandbox and its file format SPSB. This is a separate project and can also be downloaded for free. It has the zlib/libpng license as well.

Two new platforms are supported: Android and iOS, the most popular mobile platforms. Also a project file for Mac OS X has been added but this port is unfinished. For the mobile platforms two new render systems have been added: OpenGL|ES 1.1 and 2.0. For Android the new audio device OpenSL|ES has been added, too.

For renderer independent shader programming the Cg Toolkit by NVIDIA has also been integrated. Thanks to Cg among others now tessellation can also be performed with OpenGL.

In addition to the renovation the Boost C++ Library has been integrated. You have to download this library but you don't need to compile it. The engine only uses a few templates.

There are many further features and the engine got finally pre-compiled Debug and Release versions for VisualC++ 9 and 10. Have a look at it and explor the 3rd dimension from another point of view :-)

News in brief:

Getting official Sandbox Editor (The SoftPixel Sandbox is the first offical world editor for the SoftPixel Engine)
Google Android port (Now mobile applications can be written in C++ with the SoftPixel Engine for Google Android)
Apple iOS port (Support for the Apple iOS mobile platform has been added, too)
OpenGL|ES 1 renderer (For Android and iOS the OpenGL|ES 1 fixed function pipeline can be used for simple games)
OpenGL|ES 2 renderer (For Android and iOS the OpenGL|ES 2 programmable function pipeline can be used for more complex games)
OpenSL|ES sound device (For Android the OpenSL|ES sound device has been added)
Cg Toolkit (For more shader programming flexibility the Cg Toolkit by NVIDIA has been integrated)
Integrating Boost (As part of the renovations the Boost C++ Library has been integrated in several sections)
New NetworkSystem (The NetworkSystem has been recreated completely)
Lots of Bugfixes and Improvements

3rd January 2012:

Happy Birthday SoftPixel Engine! You are four years old (over 109,000 LoC).

17th December 2011:

videos

YouTube

SoftPixel Engine

7th November 2011:

SoftPixel Sandbox

25th August 2011:

SoftPixel Engine

Benedigt Eggers

softpixelengine.net

14th August 2011:

Arkanodroid 3D

Android Market

1st August 2011:

4th July 2011:

Screenshot section has been revised.

30th June 2011:

CASTLE BENCHMARK

SoftPixel Engine

8th June 2011:

SoftPixel Engine API Docu

5th June 2011:

The SoftPixel Engine 3.0 has been released (Almost 100,000 LoC - a tenth of a million)

Meanwhile the SoftPixel Engine has become more and more into a GameEngine. Lots of integrated tools like the ModelCombiner, LightmapGenerator, PathFinder, XMLParser and ScriptLoader. Finally the SoftPixel Engine got a GUI (GraphicsUserInterface) again since the old one has been removed.
More features for working with Shaders has been added: Multi-RenderTargets and Hardware Texture Formats. With these features DeferredShading can be implemented easily.

For the new PathFinder tool I used the knowledge I've got from the University of Darmstadt where I'm currently studying. It was a two-week project where we had to apply our knowledge about several path finding algorithms such as Moore, Dijkstra and A*.
In this version the engine's architecture has been changed very strong. Among others creating custom meshes will no longer handled by the scene::Mesh class but by the new video::MeshBuffer class. An advantage of the new architecture is that now the vertex- and index buffer are complete configurable. There are several default format types but you can also create your own custom vertex format to have vertex attribute support for OpenGL Vertex Shaders and/or to save VRAM.
One feature has been removed: There is no longer a SoftwareRenderer. This is because a SoftwareRenderer are no longer used since the graphics cards everyone has a graphics card. It was just a 'Gimmick' because I wanted to learn how rasterization works. But now the OpenGL, Direct3D9 and Direct3D11 renderers are more important and I want to concentrate me on these classes.

Also a big new feature: The NewtonGameDynamics PhysicsEngine (Copyright <2003-2008> by Julio Jerez and Alain Suero) has been integrated. Integration of physics simulations has never been so easy! This is the first used external library. The license is the same (zlib/libpng).

Some tutorials and API documentation will be updated in the near future and a comprehensive TechDemo - The CASTLE BENCHMARK - will come soon ...

News in brief:

BoxGUI 2.0 (A completely new GUI has been created)
Multi-RenderTargets (In the pixel shader colors can be written to several render-targets simultaneously)
Hardware Texture Formats (The hardware texture format is now choosable: ubyte, float16 and float32 which is helpful for DeferredShading)
New SceneGraph System (The scene graph system has been redesigned completely)
Universal Mesh Buffer (The vertex- and index buffer is universal to save memory and optimize the rendering process)
PathFinder (The new tool::PathFinder class can be used for efficient and easy path finding using the A* Algorithm)
PhysicsEngine (The NewtonGameDynamics physics engine has been integrated as the first external library for precise and fast physics simulations)
Software Renderer goodbye (The SoftwareRenderer has been removed because of irrelevance and waste of code)
Lots of Bugfixes and Improvements

26th May 2011:

Code::Blocks IDE

soulcon

YouTube

1st May 2011:

Download page

25th April 2011:

Mini Game Contest

17th April 2011:

SoftPixel Engine

gamekritiker.iblogger.org

12th March 2011:

Droid's Home

SoftPixel Engine

Android

22th February 2011:

SoftPixel Engine

Inkscape

vector graphics

21th February 2011:

Codelite IDE

soulcon

HLC Games Board

Tutorials

...

Easy to handle

The SoftPixel Engine is very easy to handle such as the getting started example shows. With one function you can create the following 'primitive' objects:
cube, cone, cylinder, sphere, icosphere, torus (ring), torusknot, pipe, spiral, disk, plane, tetrahedron, cuboctahedron, octahedron, odecahedron, icosahedron, teapot ("Utah" teapot), supershape.

It is also very easy to use the virtual-reality. You can use a 3d glasses with the red-/ and the green glace.

Write applications with the simplicity of Basic languages but the power of C++ and OpenGL!

Getting started

Getting started with a very small program (C++ & SoftPixel Engine v.3.0):

// SoftPixel Engine - Getting started

#include <SoftPixelEngine.hpp>

using namespace sp; // Main namespace

int main()
{

// The softpixel-device opens the screen (windowed screen / fullscreen are possible)
SoftPixelDevice* spDevice = createGraphicsDevice(
    video::RENDERER_OPENGL, dim::size2di(640, 480), 32, "Getting Started"
);
video::RenderSystem* spRenderer = spDevice->getRenderSystem(); // Render system for drawing operations
video::RenderContext* spContext = spDevice->getRenderContext(); // Render context for back buffer controll
scene::SceneGraph* spScene = spDevice->getSceneGraph(); // Scene graph system to handle a lots of scene objects
io::InputControl* spControl = spDevice->getInputControl(); // Controller for keyboard- and the mouse input events

scene::Camera* Cam = spScene->createCamera(); // Creates a camera to see our scene
scene::Light* Light = spScene->createLight(); // Creates a light (by default Directional light)
spScene->setLighting(true); // Activates global lighting
scene::Mesh* Obj = spScene->createMesh(scene::MESH_TEAPOT); // Creates one of the 16 standard objects
Obj->setPosition(dim::vector3df(0, 0, 2.5)); // Sets the object position (x, y, z)

// The main loop will update our device
while (spDevice->updateEvent() && !spControl->keyDown(io::KEY_ESCAPE))
{
    spRenderer->clearBuffers(); // Clears the video buffers (pixel- and depth buffer)
    spScene->renderScene(); // Renders the scene
    Obj->turn(dim::vector3df(1, 1, 1)); // Rotates our object
    spContext->flipBuffers(); // Swaps the video buffer, so we can see the current frame
}

deleteDevice(); // Deletes the device context and closes the screen
return 0;

}
// END-OF-LINE