Tagged: game engine Toggle Comment Threads | Keyboard Shortcuts

  • frankiezafe 23:06 on 2018-05-11 Permalink | Reply
    Tags: , atomontage, game engine, voxel   

    “The currently dominant 3D graphics and simulation paradigm, based on triangle/polygon meshes, is fundamentally flawed. Meshes only model surfaces – a hollow and thus very incomplete approximation of reality. Mesh content creation is complex and technically demanding; costly with high barriers of entry. Many layers of “hacks” (e.g. UVs) make editing and distributing mesh assets prohibitively cumbersome.”

    The atomontage engine is shifting the paradigm of 3D from surfaces to volumes. A super interesting point of view. I will start a research on libre project have the same approach!


  • frankiezafe 20:44 on 2018-03-18 Permalink | Reply
    Tags: , , game engine, ,   

    Starting godot development with a little help to Michal Seta on his OSC addon.

    First impressions are fantastic! Godot’s architecture is prepared with indie programmer in mind: the engine is obviously open source, it is really easy to interact with the core classes of the engine, receive notifications of the main events, and childish to compile!

    A really nice piece of framework!

  • frankiezafe 15:51 on 2018-01-13 Permalink | Reply
    Tags: game engine, inverse kinematics, PBR, , , urho3d,   

    Urho3D, demo session. Great work, tested on windows and osx.

    The end of the video is the discovery of the editor.

    Try out the samples.

    All examples:


  • frankiezafe 19:50 on 2017-10-06 Permalink | Reply
    Tags: game engine, pssm, , ,   

    Tech info: 3 splits, 4096, 2048 & 1024 maps, 2 pass materials on all objects, gpu: GTX 980.

    Working on an “easy” to deploy shadow system for the engine. The work now is to make the activation of these as simple as possible.

    For the moment, the activtion has to be done manually through many steps: loading specific resources, activating them, modification of the default PolymorphApplication methods, etc.

    To make it simplier, the resources should be placed in zip, like the PolymorphTrays.zip (containing the UI style), and loaded via standard methods.

    Just to mention, I discovered the “import” feature in ogre’s materials, just wonderful! To modify the appearence of the balls in the video, one just have to inherit from a complex material called two_pass_shadows declared in the shadow package, in shadows_pssm.material file.

    import * from “shadows_pssm.material”
    material ball_mat : two_pass_shadows
        pass standard
          diffuse 0.1 0.99 0.95 1.0
            texture retro.png
            colour_op alpha_blend

    see Script-Inheritance for details.

  • frankiezafe 22:35 on 2017-09-30 Permalink | Reply
    Tags: , , , game engine   

    It has been an hardcore saturday evening: i’ve struggled with Bullet for 3 hours, and, finally, i’m able to get all bullet events in my code, without having to “manually” asking to each object “are you touching somebody?”.

    It’s a bit weird, but to achieve this you have to plug a static method on the C callbacks of Bullet, called ContactAddedCallback, ContactProcessedCallback and ContactDestroyedCallback.

    To avoid ever doing this again, PBullet class has now 3 static methods to set these 3 callbacks,

    • static void setContactAddedCallback( ContactAddedCallback callbackFunction);
    • static void setContactProcessedCallback( ContactProcessedCallback callbackFunction);
    • static void setContactDestroyedCallback( ContactDestroyedCallback callbackFunction);

    In your class, you declare one method like this (.h):

    static bool myContactProcessedCallback(
    btManifoldPoint& cp,
    void* body0, void* body1) {
    std::cout << “myContactProcessedCallback: ” << body0 << ” <> ” << body1 << std::endl;

    You link it to PBullet like this (easy):

    PBullet::setContactProcessedCallback( myContactProcessedCallback );

    And it works! Result is absolutely NOT visual…

    The bullet documentation is a bit too subtle for me, I lost a lot of time to implement a ContactResultCallback before understanding that this is a one timer, the link between objects and the callback is lost at the next update…

    For the braves and the curious, here is the urls i’ve used to complete this:

  • frankiezafe 11:19 on 2017-09-27 Permalink | Reply
    Tags: , game engine, , refactoring   

    Working an important refactoring of the classes for the next release of the engine (v0.2). The works will starts beginning of 2018.

    There is a complete description of the new classes here: https://bitbucket.org/polymorphteam/pe.2.0/wiki/pobject

  • frankiezafe 19:48 on 2017-09-24 Permalink | Reply
    Tags: , game engine, ,   

    PLine, a class to draw … lines! It might seems stupid, but drawing lines is no the default purpose of a game engine. Drawing a line that connect 2 objects for instance is painfull to do with a parallelepiped, especially when you need its thickness to stay constant!

    The class PLine is there to help. You define once the number of vertices it contains, and you can modify their position at each draw.

    PLine is using the marvellous Ogre’s ManualObject and is updated only when needed thanks to Ogre::RenderQueueListener. A drawback of this flexibility is the independence to the hierarchy: if the line is attached to another object, it is not influenced by its transformation…

    Note: see http://www.ogre3d.org/forums/viewtopic.php?f=2&p=538467#p538467

  • xuv 18:52 on 2017-03-21 Permalink | Reply
    Tags: , game engine, ,   

    Polymorph Engine is on itch.io 

    The Polymorph Engine is on itch.io, the go-to community website for sharing, rating and downloading indie games. It sits in the well-named “tools” section where it is already getting some attention.

    But we need your help to bring it further. So if you have an itch.io account, be sure to check the Polymorph Engine page, download the install script, give it a 5 stars ratings, or even add it to your favorites.

    While you are there, be also sure to check out and follow Frankie and xuv profiles and collections, you might discover some gems.

    Let us know about your itch.io profile in the comments. We’ll be sure to check it out.

  • frankiezafe 21:10 on 2017-02-22 Permalink | Reply
    Tags: , game engine, ,   

    Several hours of work later, the class PMaterial is fully integrated to PNode. This part has been tricky: materials and textures are shared objects, managed by managers below the objects.

    The approach is to create PMaterial on demand, when you call pnode.getMaterial, for instance. Once created, it stays in the pnode until you destroy it or overwrite the material with another.

    This limits the memory consumption and force the coder to always retrieve the material pointer from the pnode, and not to store it.

    Another cool feature of the pnode.getMaterial is that the material can be created RT if the mesh doesn’t specify one.

    On the PMaterial level, it is becoming very easy to add the methods to access the different layers of the Ogre material.

    For instance, here is the code used to create the 2 materials applied on the balls in the image above:

    pmat_even.create( "Test", "Nice material" );
    pmat_even.diffuse( 1, 0, 0 );
    // activation of fog
    pmat_even.fogMode( Ogre::FOG_EXP );
    pmat_even.fogDensity( 0.1 );
    pmat_even.fogDistance( 10, 15 );
    pmat_even.fogColor( 0.4, 0.4, 0.4 ); // same as background
    // cloning pmat_even in pmat_odd
    pmat_odd.clone( &pmat_even );
    pmat_odd.fogColor( 0.8, 0.8, 0.8 );
    pmat_odd.shading( Ogre::SO_FLAT );
    // adding a pass on the material
    // there are now 2 passes in technique 0 of this material
    uint tid = 0;
    uint pid = 1;
    pmat_odd.emissive( 1,0,1, tid,pid );
    pmat_odd.shading( Ogre::SO_FLAT, tid,pid );
    pmat_odd.polygon( Ogre::PM_WIREFRAME, tid,pid );

    It’s super easy to clone a material, at creation or via the clone method. The second pass of the odd material have to be set manually. Passes are not cloneable (yet?).

    As you may notice, mentioning the technique or pass to attack is optional. If your material has only one technique and one pass, the call is very short. Once you beginning to build a more complex material, adding 2 uint at the end of your arguments should not be too difficult…

    The material of the cube is also created manually:

    PMaterial pmat2( pmat_even );
    // disabling the fog
    pmat2.fogMode( Ogre::FOG_NONE );
    pmat2.diffuse( 1, 1, 1 );
    // checking the number of textures
    if ( pmat2.getTextureUnitCount( ) == 0 ) {
    	// adding one 
    	pmat2.addTexture( "General", "child-computer.jpg" );
    } else {
    	// modifying the first one
    	pmat2.setTexture( "General", "child-computer.jpg" );
    cube.material( &pmat2, true );

    More, soon!

  • frankiezafe 13:38 on 2017-02-17 Permalink | Reply
    Tags: , , game engine,   

    new class in package: PMaterial.

    This class is an helper that simplify the access to the multiple layers of Ogre’s materials.
    There are 3 levels in a material:

    • technique
    • pass
    • texture units

    The usual Ogre way to access to modify a pass diffuse is looking like this:

    Ogre::MaterialPtr ptr =  Ogre::MaterialManager::getSingleton( ).load( "mat", "group" );
    ptr.getTechnique(0)->getPass(0)->setDiffuse( 1,0,0 );

    Using PMaterial, it looks like this:

    polymorph::PMaterial ptr;
    ptr.load( "mat", "group" );
    ptr.diffuse( 1,0,0 );

    Selection of technique and pass is optional. The image above shows the fog configuration:

    pmat.fogMode( Ogre::FOG_EXP );
    pmat.fogDensity( 0.1 );
    pmat.fogDistance( 10, 30 );
    pmat.fogColor( 0.4, 0.4, 0.4 );

    All methods are not yet there, do not worry, they will come soon.

Compose new post
Next post/Next comment
Previous post/Previous comment
Show/Hide comments
Go to top
Go to login
Show/Hide help
shift + esc