David Piuva's graphics engine

On this site, you can download my graphics engine for DirectX 11 with full DirectX 10 hardware support. The core of the engine is written in C++ and the tools are written in Visual Basic for safety and fast development.

        The engine is given out under the zlib open source license. The source code is included in the packet.

Things you need to know:
            Visual Basic 6, 2008 or newer is recomended to use for your projects but you need
            VB6 for modifying the model editor since converting over 8000 lines would be a real pain.
            C# is good if you already know C++ or Java.
        Basic linear algebra.
            Matrix multiplication, cross product, dot product, normalizing...
        3D modeling.
        How to write HLSL shaders without deep understanding.
        How to use MFC ActiveX components in your favourite language.

System requirements:
        That old retro thing grampa uses called Microsoft Windows.
        Admin access to register the ActiveX component using a batch file.
        Graphics card compatible with DirectX 10.0 and shader model 4.
            The engine do not use detail tesselation because I have not yet seen
                any game that looks any better with detail tesselation activated.
                Normal based triangle patches are faster and easier to use.
        DirectX 11 compatible version of Windows.

Design decisions:
        Instead of having optimization for small static worlds, this engine
            is made for procedural generation of large worlds.
        Instead of having a lot of obsoleted methods when the engine gets old, a
            small list in Upgrade.html that usually is empty will tell you how to
            emulate old methods or what default value to add in a new argument.
        I only release major versions so that your application is calling the
            same version of the engine that the application was tested with.
        Instead of having many redundant ways to rotate things in the engine, you are
            assumed to know basic linear algebra and just place things where you want them.
            This improves performance, stability, data visibility and model-view separation.
        The engine is not intrusive with any high level things that you can make yourself
            because that would be like selling a half finished painting as canvas to an artist.
        Learning how to make games while having fun is more important than selling and
            therefor the engine is available to multiple languages instead of multiple platforms.
            Since Windows will not last for long, I am now investigating the possibility of making
            a lightweight graphics library for games in Linux.

        Formal documentation with explaining images.
            Preconditions, postconditions and sideeffects are declared.
        Guides for upgrading, optimizing and debugging.
        Examples in Visual Basic 6 that can be converted to newer versions of Visual Basic.
            Visual Basic 6 is around 10 times as fast as .NET.
        An easy to use model editor will let you:
            Create low detailed models from scratch by drawing polygons or modify existing models.
            Import Wavefront OBJ models.
                Tested with Blender and 3DSMax.
                It might not work with all applications claiming to support OBJ because every application
                choose their own subset of features to support from the full specification.
                The importer is an open VB6 module (Importer_WavefrontOBJ.bas) with
                less than 400 lines of code that you can modify if your files can't be imported.
            See the final result with your own shaders while editing.
            Create a skeleton and assign vertices to bones.
            Modify UV coordinates directly.
            Modify the source code in Visual Basic 6 to create your own tools.
            Generate tangent space for tangent space normal mapping and parallax occlusion mapping.
                The SDK include a shader with edge sampling parallax occlusion mapping
                  that remove the layer artivacts completely at a high performance cost.
        A sound encoder/decoder for converting 16 bit wave sounds to the engine's compressed format.
            The compression ratio and sound quality is near lossless because anything less sounds like crap.
            A lot of sound codecs assume that the sound will be played in original speed at medium
            volume which is almost never the case with sound in games.

        * Foolproof safety using reference numbers instead of pointers to things in the engine.
        * Post effect system.
        * Native text based model format that is easy to understand.
        * CPU buffers can copy data from the graphics card for GPGPU computation.
        * Sky instance system that allow one instance to be drawn behind everything else.
        * Geometry shaders.
        * Simple 3D sound engine.
            My own compressed sound format for high quality in memory sounds. (No streaming)
        * Wrapper for the Bullet physics engine to make it as safe as the graphics engine.
        * Depth based shadows with automatic artifact removal.
        * Cutting plane for reflection and refraction.
        * Bone animation.

Why I know how to make a graphics engine:
        I have made around 250 computer games since I was a child and one of the games
            was nominated for best execution at the "Swedish Game Awards" 2008.
        I have a 4 year master degree in computer science (Filosofie Magister) from Uppsala University.
        I now work full time as a software developer / algorithm designer in digital video analysis.

        You can contact me using the Google group if you have any questions or bugs to report.