Jump to content

Canardian

Members
  • Content Count

    4,033
  • Joined

  • Last visited

Blog Entries posted by Canardian

  1. Canardian
    Recently I blogged about Holiday planning, and in last minute I decided to destinate for Kemer, Turkey.I must say, it was much better than I could ever imagine. Something touched me there, really deep.The culture, the style, the origins, it's a mystery. But them, as we fins share that destiny. I interviewed some locals about their origins, and it seems that we both came from the same geographical area, Ural, Russia. The turks just shifted a bit more south, intervening with chinese and oriental cultures, while the fins headed north to a merely uninhabited area, except for the confrontation with the native sami people.While Kemer was a small and peaceful town, with all the environment you would expect for a sun beach holiday, it had also amazing mountains raising directly from the sea, and the sea was shallow and turquoise for miles ahead. But that was not was touched me, although even that was way over my expectations. What really got me is hard to explain, it's a combination of their language, culture, music, and style. You can't imagine how dry western cultures are compared to that kind of love of life. I was close to tears and beyond from pure joy and love from almost everything there. Paradise lost & found.
     
    Source
  2. Canardian
    Project Majami is going forward again, as I got an opportunity to meet the singer of the band soon. I've started to create some sound samples for ModTracker, so we can record the vocals while he can sync his singing speed to the final song.After the singing is recorded, it's just up to me to play the final instrument tracks and finish the song. I think this will be the main guitar, as it has some unique distortion and sound: Main Comp Guitar (this is just a quick test, so it contains life errors in rhytm and note accuracy).Now THIS is wierd: I just bought the newest CD from Obituary, called Frozen in Time, and the first song is very similar to our planned main comp guitar (same notes, but slightly different playstyle - well, the typical Obituary notestep style of course). I swear I never heard of their song before today, and the original riff for Majami was done over a year ago. Somekind of telepathy? Then again, this pattern has been probably played by hundreds of bands before, as it's very simple yet metal genre specific one. But still a wierd coincidence that it happened almost at the same time (around 10 minutes before) when I played it, before I opened the CD case and listened to theirs...EDIT: Now I listened again to the original Majami working draft, and it was not exactly what I just played. It was similar, however inversed down, and shifted 4 notes up. Ok, it could be explained that I have tested some new sound patterns since then, and probably just assumed that I originally played it using the improved sound pattern.
     
    Source
  3. Canardian
    People are wondering what language they choose with Leadwerks3D. Sometimes they have some exotic languages in mind, but quite often it comes down to the decision between Lua and C++.
     
    Recently I read an article that LuaJIT (yes, you can use it in Leadwerks3D too) is actually damn fast. It's fast, because the simpliness of the language allows for extreme optimizations. It might even come close to C++ speed, or in some cases even exceed it. That's how fast LuaJIT 2.0 is. But it's still in beta, so it can only get faster.
     
    Same goes for Fortran 2008 btw, it usually beats the speed of C++, because the compiler knows which CPU registers are in use and can assign them intelligently, which C++ can't, since it doesn't know which registers are in use. But it doesn't have such nicely optimized STL libraries for linked lists and stuff, so it ends up slower in those cases, because nobody can single handed make such great optimizations as STL provides.
     
    Lua has some advantages and also disadvantages over C++.
     
    The advantages are:
    1) You can use the same code on all platforms, which makes finishing your game much faster
    2) You can develop in real time, because you only need to compile for the final release of the game, if even then, but usually you will need it if your game does some more complex calculations, and to make sure your game runs also well on slower machines
    3) You can learn it much faster than C++, it's really just basic, and often even easier than that because there are no types and other annoying stuff
    4) You can share code with other people much easier, because like beforementioned, nothing is type specific, which allows for extreme abstraction and generic code
     
    The disadvantages are:
    1) You don't have such great arsenal of 3rd party libraries ready for Lua, although with some effort you can find some libraries which someone has made, or you can take any C/C++ library and wrap it yourself for Lua
    2) If you really need maximum speed for some time critical routines, you still need C. Yes, not even C++ is fast enough for those. And then you need to wrap them again for Lua
     
    For reference, here is an article that LuaJIT can actually even come on par with C in some benchmarks:
    http://lua-users.org...6/msg00071.html
     
    On the other hand, I think with the growing interest for Lua in Leadwerks3D, the Werkspace asset store will provide more and more ready made libraries for Lua over time.
     
    My conclusion is, that LuaJIT 2.0 is a very easy and fast alternative to C++ with Leadwerks3D, and it allows also sharing of code and code snippets much easier than C++ does. Which is what the Leadwerks Community is about.
  4. Canardian
    I'm dreaming of Leadwerks3D, and while waiting for its release in June, I have already many ideas what I want to do with it. Then I realized, it's actually much more than just a 3D game engine, because it allows to have a OpenGL context on all devices, including Android, iPhone, iPad, PC, Mac, Linux, and more in future. In addition, it allows you to code in C++ on all those devices, which means that also high level languages, like my SuperBasic will work on all platforms, because it uses a C++ compiler in the backend, and of course the SuperBasic precompiler which is written in C++ too.
     
    This would make it possible to have a programming IDE and game editor even on mobile phones.
     
    Now that again means, that we should actually do all development of GUIs, applications, including business applications and tools with Leadwerks3D itself, and not use some external libraries like Qt, GTK+, GLUT, SDL, etc..., because then it would not work all platforms again, at least not directly.
     
    We only need that Leadwerks3D has all the minimum required libraries built-in, which are needed for game development, since game development is much more demanding that other applications. So there should be SQLite3 and libCURL by default in Leadwerks3D too, so that we can have a fast database system and easy HTTP/FTP access with the native engine commands. With a simple HTTP command set I could make WebService calls and other HTTP stuff on every device, which is the most important feature of modern applications. Everyone is connected that way, and can integrate with any system.
  5. Canardian
    I decided to try out Qt, and was shocked how easy it was to "install" and use.
    I only unpacked the mingw-Qt zip to my h:/lib/qt folder and it was "installed".
    Then I only added the QtCore4.a and QtGui4.a to my codeblocks project's linker settings, and added the h:/lib/qt/include and h:/lib/qt/include/qtgui folder to my project's source files tab, and then I put the QtCore4.dll and QtGui4.dll in the same folder where my game.exe was.
     
    A simple demo program like this already makes a fully functional text editor:

    #include <QtGui> int main(int argc, char* argv[]) { QApplication app(argc, argv); QTextEdit edit; edit.show(); edit.append("Hello World!\n"); return app.exec(); }

    It compiles in less than a second with codeblocks too B)
    Now I will learn a bit more how to use Qt, and then make a demo with LE2 using Qt.
    I think this will be the ultimate killer GUI, because it's so easy to use and extremely lightweight and fast (it only links what you use).
    And it looks like it uses by default the OS style too, what Josh likes.
  6. Canardian
    LEO 2.5 has been sent to Josh, there was a few commands missing, and a few bugs were fixed.
     
    GameLib 0.1.2.0 should be ready soon, I'm still testing the new additions to the Application class. It can get quite deep to make a simple spinning cube template, if you want to make it perfect.
     
    For example the window size needs to be read from a config file rather than from LEBuilder, so that it is not hardcoded into the game code. I ended up with the decision to make all config, gamesave, etc... files as sqlite3 databases. It makes things more standardized, as I found out that Apache PHP5 has also built-in sqlite3 support. Since GameLib's Window class supports also a seperate viewport area which can have a different resolution than the windows/fullscreen mode, that should be put into the config.db also.
     
    The idea behind the viewport area is that people want to play games in fullscreen mode, but sometimes their GPU is too slow to run 1920x1080 or even 1680x1050 fullscreen modes, so they can still run in fullscreen mode with a lower resolution viewport. It then also allows some GUI elements to be in full resolution.
     
    Next comes a GameLib Spinning Cube template for LEBuilder, and after that a simple FPS template also. And even after that a simple RTS template.
     
    I'm trying to keep GameLib as simple as possible to use, but it can be difficult at times, because it needs to stay universal, and not hardcoded for a specific game/application style. LEBuilder will help me a lot to keep things easy to understand for new users, as they only need to know how to achieve things, and not how it internally works. In the same way as I find STL easy to use, the way how it internally works is way too deep for anyone to understand. I just need concrete, compilable examples, and documentation, and it's easy to use.
     
    And right now we got a new version of LEBuilder tested and done with ZioRed. It supports auto-quit after building a project (you have to set the flag to True in the config xml), and it remembers the last project root directory. ZioRed sent the exe and source to Josh too, so this will be included in the official SDK also.
  7. Canardian
    Modding games is a popular sport, and very productive, since you don't have to code usually much, maybe some little additions only.
    However, modding has its limits, as you are usually bound to a quite hardcoded game genre environment, unless you use Garry's Mod or something, but that has then it's own limits too with the engine features.
     
    Since I am currenly building a GameLib FPS template for LEBuilder, these thoughts came up. What the template will do, is to create a simple FPS game with one mouseclick. After that, you can compile it, and it just works. You can open the level1.sbx or level2.sbx in Editor, and it just works. However, since the time critical game logic is done in C++, you can't play the game in Editor, but you can edit it in 3D WYSIWYG very well. I think that is good enough. LE3 Editor will be done that way anyway also.
     
    From a modder's perspective, you basically create a vanilla game, and then you "mod" it with Editor. You don't necessarily have to code anything in C++, but you can, if you want. Nothing is hardcoded in GameLib, you can choose which commands to use and when, and you can even choose to write your own commands which you use as standard GameLib command replacements. The C++ part of coding gives an unlimited possibility to "mod" the game to your imagination, and time critical routines will never be a handicap, because it's C++. With Lua or other slower languages you might encounter problems with time critical routines.
     
    If you don't want to learn C++, you can also ask me for new GameLib features in the Werkspace Forums, which I will then implement as Editor Thingoids or Models. So basically most feature requests from artists and modders are about adding new GameLib Thingoids to Editor, and I have then to check myself, if the vanilla FPS template C++ code needs also some additions. But you don't have to care about that, it's my job, and I love to do it.
  8. Canardian
    Things change
    and other things using those things must be updated from time to time to keep them working properly.
     
    Leadwerks Engine C/C++ was originally designed to work only with VS 2008, but keeping GNU C++ in mind, then a few updates were made to make it work with MinGW 3.4.5. Now MinGW 4.5.2.1 has been updated to support the newest C++ standard, and so a few updates need to be done in the Leadwerks Engine C/C++ headers too. But don't worry, those updates are fully backwards compatibe, so it will still work in MinGW 3.4.5.
     
    I've fixed today a few warnings with MinGW 4.5.2.1, and a few more are still remaining, which I will fix today also. VS 2008/2010 and Dev C++ work of course too, as these are only official C++ standard related fixes.
     
    When the official headers are updated, I will proceed with adding klepto2's new commands into a seperate community edition of the C/C++ headers, while he is maintaining the C# community edition headers.
     
    And even after that, GameLib needs to be updated too, to give no warnings with MinGW 4.5.2.1. But these will be natural updates as I fix them while I'm writing a few small example games with gamelib.
     
    I've setup release dates for these things also:


     
    2011-07-22 Official C/C++ headers update
    2011-07-23 Guess A Number game: Adding gameplay features
    2011-07-25 Community Edition C/C++ headers
    2011-07-30 Fortran headers

    Now I'm taking ideas what kind of other mini games you want to see made with gamelib. I've already planned a Tower Defense 3D game, but that is not so mini
     
    EDIT:
    Status update on 2011-07-25:


     
    engine.cpp and engine.h are ready and sent to Josh
    LEO was missing Body::SetForce and Body::SetTorque completely, so I added them
    all gamelib warnings with MinGW 4.5.2.1 have been fixed
    Guess A Number game is almost ready for beta testing
    Seems like the votes go for a mini RTS game next
     

  9. Canardian
    Today I wanted to start a GameLib tutorial series, and wanted to eliminate all temporary code and build the tutorial from beginning so that it will only expand and build on the previous tutorial steps.
     
    Loading models and creating meshes programmatically is out of question, as you don't do that in real games. You would at least somehow have them loaded from a config file.
     
    Then I thought I should put all assets into a Leadwerks Editor scene, but that won't work with real games either, as you can't save gamestates with sbx files. Well, you could have a small seperate gamesave file, but then you would need to load the sbx file each time and remove things which are not there anymore in a later gamestate.
     
    Then I thought that having the assets in a sqlite database would work, as then I can just save changes into the database, and it would load much faster than a sbx file anyway, since it would load only assets in camera range. Of course the game should leave the original sqlite database unchanged, and rather use a copy of it. A combination of static scene dbs and dynamic scene dbs, and also partial scene dbs would work.
     
    There's only a little problem using sqlite databases with LE: There is no visual 3D Editor for Leadwerks which can use sqlite databases! With sqlite3 there comes a handy table editor, but that's not enough for making game scenes.
     
    As I'm working on a dynamic MMO also, and I wanted first to make the GameLib tutorial series to see that everything works, it seems I need to make a Leadwerks Editor SQL first. If my game uses sqlite scenes, the Editor would be needed also by team members who are working on the game content.
     
    The first version of Editor SQL can be quite simple. You can place models in front of the camera, and then you can move/scale/rotate them with the cursor keys, including grid alignment. Scaling should be possible, if I study the phy file format a bit, and change the phy file according to the mesh's scale.
  10. Canardian
    I'm testing Code::Blocks with LE2, instead of Visual Studio 2008/2010.
    So far it seems quite nice, and very intuitive to learn and configure.
    I already found some benefits of Code::Blocks over Visual Studio:
     
    1) LE2 syntax highlighting can be configured to be different from the built-in C++ keywords. In VS they always have the same color.
    2) Compiling time is much faster, because it can use MinGW.
    3) Generated code is much faster, because it can use -O3 and -O6 optimizations.
    4) Loading the IDE is much faster.
    5) Compiling can be configured to stop at the first error, while in Visual Studio it always tries to compile the whole source code first which takes ages and is useless if there was a first error.
    6) Code::Blocks works also on Mac and Linux, so you can have the same IDE under any OS.
    7) Using MinGW in Code::Blocks gets rid of the VS RunTime needs, which needs the user to install MSVCRT90.dll, or you to include them in an Microsoft.VC90.CRT folder with your game.
    8) Intellisense is super fast and smart. It shows only keywords which match what you typed so far, and it works with LE2 commands too.
    9) Code::Blocks work also with Wine in Linux, while Visual Studio does not, so you can use Linux to write and play your LE2 games. Wine runs also LE2 games 20 FPS faster than Windows XP (and of course much faster than Vista/7, since XP is much faster than those).
    10) Showing/hiding the console window of LE2 can be easily turned on/off in Code::Blocks with the -mwindows linker option, while in Visual Studio you need either some preprocessor pragmas or some complicated System target settings.
    11) Code::Blocks cleans up whitespaces after lines automatically, while in Visual Studio you have to do this manually.
     
    I will make a tutorial how to setup a LE2 project with Code::Blocks next.
  11. Canardian
    I just had a 3 day course about Advanced C++ programming.
    It was pretty cool, and I enjoyed every second of it.
     
    I already knew most of the C++ language itself, but I've never taken any course about the different ways of programming, and which way suits best each solution. This was exactly what I wanted to learn, and I feel much more professional now
     
    The course talked about the following things, and we had to write also real C++ code for most of the ways we just learned and compile and run it. It was organized pretty smart, as many topics built upon a previous topic, and the code we wrote earlier. That was fun also:
     
    Design Patterns:

    different models and their usage
    GoF-models (GoF=Gang of Four: http://en.wikipedia.org/wiki/Design_Patterns )

    Creational Patterns:

    Abstract Factory
    Builder
    Factory Method
    Prototype
    Singleton

    Structural Patterns:

    Adapter
    Bridge
    Composite
    Decorator
    Facade
    Flyweight
    Proxy

    Behavioral Patterns:

    Chain of Responsibility
    Command
    Interpreter
    Iterator
    Mediator
    Memento
    Observer
    State
    Strategy
    Template Method
    Visitor

    Antipatterns:

    usual problems in class design
    solutions to problems

    Each of those topics exposed a different way of programming in C++, and it was pretty amazing what kind of features are hidden in C++, of which most people probably never thought of before.
     
    I had no idea how powerful and easy C++ really is, when you use it the real C++ way. Basically it was like, you should use classes for everything, and never do big if() constructs and other hardcoded and procedural logic.
     
    Doing things right in C++ gives also a huge speed boost in execution and programming time, and makes code really reusable, as they explained why each const, virtual, static, volatile, mutable, stack, heap, algorithm, etc... is useful.
  12. Canardian
    Humankind never had a chance.
    They came from the skies,
    like they did before,
    but this time they were not our gods
    - they were our fate,
    or so it seemed.
    We called them the Anushar, since that was the only thing we knew about them: the name of their leader.
    A few of us survived, perhaps because we were weak,
    and didn't appear to be a threat to them.
    This is where my story begins...


    Just testing the storyline for the new model I'm getting soon
    I'm so excited about it and hope that it will be what I always dreamed of!
     
    Now when I think about it, isn't it like a toy, which you get with a collector's edition of a game, but having it as a in-game 3D model is much more fun since you can put it in all your games and demos.
     
    Of course there will be a game also where it plays the main role, but first I need to finish another game, and another one still after that.
     
    Oh, this song tells a story about the great war against the Anushar too. What she calls "You" is what we know as God today, he is one of them:


    But there's more to it, why he did what he did, so see you in the game!
  13. Canardian
    I have many projects going on, some have been going on for years, some were finished in very short time. When I got all pieces together, then projects are finished in very short time, and when some essential piece is missing, it will keep the project open until... well, until the piece is found.
     
    I was inspired to write this blog, because today I saw many pieces come together. Not just one for one project, but multiple for multiple projects. Actually this wave started already yesterday, and today even more things came together.
     
    Some of the big projects are:
     


     
    Lucid: a 3D system, not exactly an OS, although it replaces many OS features. It has for example a insane fast file system, which is done on another core, so it doesn't affect the main program at all. And that file system is a database, what Microsoft planned for Windows since years, but never managed to do it. Lucid was on hold for many years, since OpenGL didn't work on all computers. Now it does, even on Intel GMA. The missing piece was to find the right 3D rendering engine, now it's clear that it's Ogre3D/BlendELF, and it might be just one after testing which one wins the low-end limbo.
     
    Mimic AI: a research into reverse AI (the name Mimic AI comes from the fact that it actually behaves more like real humans (it blatantly mimics them), rather than using some intertwined logic), which I found very funny, since it was quite accurate and indistinquishable. Now I found a real application for it: the Human language, which will essentially transform spoken english into C++, Lua, BlitzMax and whatever it "knows". The knowledge database is a simple text file, but it could be a SQLite3 database also, but that's not needed yet until the size of the database grows too big to be in-memory only. The missing piece was to find a real use for Mimic AI, and also a language which can be used for any game, tutorial, documentation, etc... So that there is no need to have multiple languages.
     
    Blitz3D 2.0: I wanted to have a low-end capable 3D engine, preferrably cross-platform. Ogre3D with Bullet and/or BlendELF seems to fulfill this job best. Yesterday I realized it will also fit the job as core rendering engine for Lucid. The decision for Bullet was not a simple one, and I did a lot of research into ODE, PhysX, Havok also, and Bullet came out as the winner. The missing piece here was to find a low-end engine which can also do shadows and physics.
     
    A real game in LE: I found a nice team, and LE 2.32R5 is finally a
    completely bug free engine (not sure about the programmatic terrain editing yet, but I will find it out tomorrow). I also found today finally - after having searched for 3 years - an artist to make the LCP alien model. I told him a price range of 50-200€ and he snapped immediately a deal. The missing piece was to find a team which was dedicated to finish a real game, and the secondary objective to find an artist to make the alien model.

    So now I have the missing pieces for 4 of my big projects. Now it's time to code
  14. Canardian
    I had some funny idea again, and started to make Leadwerks Navigator.
     
    It's a simple web page which allows the user to choose different paths and areas of information about Leadwerks Engine.
    The deeper he navigates and into the more advanced topics he goes, the higher level he gets.
     
    I have no idea how useful this is, or if the Leadwerks web site will be easier to navigate,
    but at least it's fun to do! :
     
    http://www.siipi.com/leadwerks
  15. Canardian
    I introduced my new language earlier in Roland's Wizard thread, so I thought I could explain it a bit more.
    Of course a new language is always seen a bit sceptically by people, and they wonder why is it needed, or what benefits does it bring.
     
    At its first version, Easy is still very simple, and based on Variadic Macros (macros which can take a dynamic amount of parameters), and I hope I can keep it that way, and not need a seperate preprocessor, since it would break some features, like direct compiling in Visual Studio and other compilers, and in other languages too.
     
    Although Easy is not always less to code than C++, BASIC or Pascal, it should be still faster to code with, as you don't have to type characters like "{", "}", "=", "<", ">", ":" and ";", but you always use only "(" and ")". So it's less thinking while coding (or looking up help files and examples), and it should get quite intuitive after writing your first few programs.
     
    Let's compare C++, BlitzMax and Easy code:
     
    C++:

    #include "stdio.h" int main() { printf( "Hello World!\n" ); for( int i=1; i<=10; i++ ) { printf( "%d\n", i ); } return 0; }
     
    BlitzMax:

    SuperStrict Print "Hello World!" For Local i:Int = 1 To 10 Print i Next
     
    Easy:

    #include "easy.h" Begin Print( "Hello World!" LineFeed ) For( Int, i, 1, 10 ) PrintIntLine( i ) End Return( 0 ) End
     
    As you can see, Easy has the least amount of special characters used, and everything is kept simple using a few characters: "(", "," and ")". It's also more readable (round brackets are reader friendly also in mathematics, as they do the thinking for you, when combining multiplication, division, powerization and addition in formulas), especially for persons who don't know the language in question (C++ or BlitzMax).
     
    The line feed handling is still something I'm thinking about, it could end up as: PrintIntLine( i ), or PrintInt( i, LineFeed )
     
    The official Easy web page can be found here:
    http://www.siipi.com/easy
  16. Canardian
    Is to make games as easily as this:
    http://fuse.microsoft.com/kodu/
     
    Editor can get very close to that, by creating Thingoids and Models for it.
    You can make those kind of ad-hoc menus in Editor using Thingoids, and have Models have their own logic so you just place them in Editor, and they get alive.
  17. Canardian
    Josh talked about the new engine integrated Framework:
    http://leadwerks.com/werkspace/index.php?/blog/1/entry-57-merry-christmas/
     
    The engine integrated framework is the only way at the moment to have LUA and C++ code use the same framework instance.
    This brings some great benefits over the old way how framework works:
    1) You can have LUA scripts which access framework commands, and they work also in your C++ program. Earlier the LUA scripts could not access the framework commands of your C++ code, and you couldn't create a 2nd framework instance from LUA either, since it would have caused a big mess.
    2) You can port framework to other languages much easier now, as you only need to port the C headers.
    3) When framework is modified, you barely need to do anything to update your "other than BlitzMax or C/C++ code". In most cases the modifications and updates are only internal, so the interface doesn't change. In this case you don't need to do anything. In the case that the interface changes, you only need to update the changed interface commands.
     
    Although the C/C++ framework source code will still remain, it is not needed at the moment (it will be needed later on when LE is ported to C++ (officially (for console ports), or inofficially (by source owners)). I think that now it will mostly serve as documentation how framework works internally.
     
    At the same time framework will get a more object oriented environment also, since LEO needs to access it too.
    Optimally, game developers would use LEO and Lua, as their syntax is almost identical (and can be made even more identical when Josh makes every Lua command OOP style). I say optimally, because with the combination of LEO and Lua you get the fastest possible code for a game with the biggest 3rd party library support (from LEO), and also the easiest, most interchangable and fastest to code code (from Lua).
     
    GameLib 0.0.16.0 will also use the engine integrated framework, so it will bring another boost to C/C++(LEO) game development (and to BlitzMax and to other languages if the community would be more supportive in porting GameLib ). Although if the C++ game development accelerates even more in future, soon anyone not using C++ would be a fool and waste his time, and that's not a bad alternative either. I personally think that the world would be much more advanced if people would stop making new languages all the time (there are over 350), and focus on C++ only.
  18. Canardian
    I was just adding wheels to my airplane, and noticed how much time the realtime LUA programming saves me when I was adjusting the positions of the wheels to their exact position. Having the airplane model positioned and zoomed on my screen, I added some code to load and position the wheels, and after each character change in code (like finding the value Vec3(0,0.125,2.01) for the front wheel), I pressed Ctrl-S and saw the result immediately on the screen.
     
    Using C++ or any other compiled language this would have taken me a lot more time, with all compiling and restarting between each adjustment.
     
    Even if I still need some C++ code for time critical things and 3rd party libraries, all the execute-once-at-startup code done with LUA reduces the amount of C++ code and programming time incredibly much.
     
    An industrial programmer who's getting paid for his work per hour, would probably save the company 50% of unnecessary expenses without that the programmer gets less salary, and the programmer would also get more motivated and have more time to focus on quality, since he is now so productive with Entity Oriented Realtime 3D Programming.
  19. Canardian
    For almost a year Max3D lead the charts, but the single fact that LE has now realtime scripting, brought it 1 more point, totalling in 14 points and beating all other engines on the market:
    http://siipi.com/public/mika.nsf/0/2AAC3EECC888AC57C22575F7004ADC16
     
    Some people might need a low-end engine, but this very same chart provides that information also:
    You just look which engine has low-end support and is ranked highest.
    The same way you can find the best engine for your needs, if you have similar special needs as low-end support.
     
    Anyway, congratulations Josh, for getting number 1 with your engine
    And I think this was just the beginning of a new era, called Social Game Development.
    I can foresee that LE gets even more points in future, broadening up the gap to other engines.
  20. Canardian
    I've been experiencing a distinquished behaviour of the community for some time.
    It's like when someone advances in his work, suddenly everyone else advances too.
     
    Yeah, I know in history also similar or identical inventions have been made around the world at the same time without that the inventors were connected or cooperating anyhow with eachother.
    There has been made also tests with apes, who learned that a banana was served in a certain spot, and new apes would go to that spot without never having being in contact with the previous apes who learned it.
     
    I don't call it supernatural, but there must be somekind of impulse and sharing of knowledge, over the remaining 7 dimensions we know of today. Sure, the tools, libraries, code snippets, demos and the entity packs which LE 2.3 now supports will play a big role too in this evolution. Soon everyone will get a lot of fully working and exchangable models with their own logic shared via this site.
     
    There has been a lot of people asking about real games made with LE.
    I think when the first one comes, suddenly a lot will come at the same time or shortly after.
    Especially with this new social development site.
     
    Of course there has been a few dozen playable games already published with LE, but no real games, like Crysis, which go fully commercial and AAA with every little tweak and trick and most polished arts possible.
  21. Canardian
    RankNameOpenGL SupportBasic Dynamic ShadowsFull Dynamic Shadows256+ Dynamic LightsRealtime GIOGG SoundsC/C++ SupportRealtime ScriptingSource Code IncludedEntity Based SystemLow End SupportHigh End SupportPhysicsOpenGL CommandsRealtime EditorCross-PlatformNetworkingPrice under $1000TotalScoreImportance151016141211332471117568091Leadwerks EngineYesYesYesYesNoYesYesYesNoYesNoYesYesYesYesNoYes200142Max3DYesYesYesYesNoYesYesNoYesYesNoYesYesYesNoYesNo0133CryENGINE 3NoYesYesYesYesYesYesYesYesNoNoYesYesNoYesNoYesNo124Unity ProYesYesNoNoNoYesNoYesNoNoYesYesYesYesYesYesYes1499115Xors3DNoYesYesYesNoYesYesYesNoYesYesYesYesNoNoNoNo100116Chrome 4NoYesYesYesNoYesYesYesYesNoNoYesYesNoYesNoYesNo117TorqueYesYesNoNoNoYesYesYesYesNoNoYesNoNoYesYesYes1000118EsenthelYesYesYesYesNoYesYesYesNoNoNoYesYesNoYesNoYes7000119Ogre3DYesYesNoNoNoYesYesNoYesNoYesYesNoNoYesYesNo01010IrrlichtYesYesNoNoNoYesYesNoYesNoYesYesNoNoNoYesYes01011Flow3DYesYesNoNoNoYesNoNoNoYesYesYesYesNoYesNoNo50912C4 StdYesYesNoNoNoNoYesNoYesNoNoYesNoNoYesYesYes3509133D Game Studio A7NoYesNoNoNoYesYesYesNoNoNoYesYesNoYesNoYes199/899914MiniB3DYesNoNoNoNoYesNoNoYesYesYesNoNoYesNoYesYes80915Ninfa3DYesYesNoNoNoYesNoNoYesNoYesYesYesNoNoNoNo0816Truevision3DNoYesYesYesNoNoYesNoNoYesNoYesYesNoNoNoNo150817Nuclear FusionNoNoNoNoNoYesYesNoYesYesYesNoNoNoNoNoYes59718Blitz3D SDKNoNoNoNoNoYesYesNoNoYesYesNoNoNoNoNoYes100619Blitz3DNoNoNoNoNoYesNoNoNoYesYesNoNoNoNoNoYes1005More rows and columns still coming... You can suggest what other engines you want on the list, but please provide the column infos, as I own/know only these engines. I'm more interested in higher rank engines though, as there are tons of lower ranks engines on the market, but I will still add low rank engines too, if I got all info for them.Explanation of the columns and their relevance:OpenGL Support: This feature is important for people who want to make cross-platform 3D development.Basic Dynamic Shadows: Basic or incompletely implemented Dynamic Shadows. Some engines don't have point light shadows, some have only stencil shadows.Full Dynamic Shadows: This means that all lights cast realtime shadows on all 3D objects, including self-shadowing, which means that a 3D object casts also shadows on it's own surfaces, and not only on other surrounding 3D objects. Also PoM shadows (=shadows from 3D textures) are needed to qualify as a Full Dynamic Shadows engine.256+ Dynamic Lights: This is only possibe with deferred rendering capable engines. The alternative to deferred rendering is forward rendering, which allows only around 128 dynamic lights (using a 128 buffers hack) due to color overburn and too low performance if you go above that. However, in most cases only 4 or 8 dynamic lights are used in forward rendering engines.Realtime GI: Realtime Global Illumination means light bounces, color bleeding and specular effects in realtime.OGG Sounds: The Vorbis OGG audio compression format allows high quality sounds at low file sizes and streaming. Also licensing issues are important for 3D application development, where the OGG format provides a GPL free license.C/C++ Support: The C and C++ programming languages have been the de facto standard for industrial computer software engineering since 1972 © and 1978 (C++). The support for external standard libraries is huge, and thus saves companies a lot of time and money when developing computer software. They create also the fastest applications.Realtime Scripting: The engine can be controlled using a script language, and scripts can be changed on the fly.Source Code Included: The engine comes with its source code. Many engines have also a seperate Source Code license, which can be very expensive.Entity Based System: This means that everything in the 3D world is a 3D Entity (sounds, cameras, models, pivots, lights, emitters, etc...), which can be controlled with the same commands like MoveEntity, ScaleEntity, TurnEntity, HideEntity, ShowEntity, etc...Entity Based Systems provide an easy learning curve, and powerful operations with simple commands, since no academic 3D matrix math is needed to be learned by the user.Alternatives to an Entity Based System is a Node Based System or a Tree Based System.Low End Support: This means basically that the engine can run with any existing graphics card.High End Support: This means that the engine supports modern AAA 3D technologies, and requires a SM3/SM4 capable graphics card.Physics: The engine has physics built-in and integrated.OpenGL Commands: The user can freely program in OpenGL language on top of the engine's 3D rendering. This is normally needed only for special purposes, like for example drawing 3D lines in the 3D space. Usually the engine renders 3D graphics much faster due to its internal optimizations.Realtime Editor: The engine has a native or 3rd party with plug-ins 3D Editor which shows the results of editing in realtime.Cross-Platform: The engine runs natively at least under MacOSX or Linux.Price under $1000: A point is given if the engine costs $1000 or less.
     
    Source
  22. Canardian
    Rank
    Name
    OpenGL Support
    Basic Dynamic Shadows
    Full Dynamic Shadows
    256+ Dynamic Lights
    Realtime GI
    OGG Sounds
    C/C++ Support
    Realtime Scripting
    Source Code Included
    Entity Based System
    Low End Support
    High End Support
    Physics
    OpenGL Commands
    Realtime Editor
    Cross-Platform
    Networking
    Price under $1000
    Total
    Score
    Importance
    15
    10
    16
    14
    12
    1
    13
    3
    2
    4
    7
    11
    17
    5
    6
    8
    0
    9
    1
    Leadwerks Engine
    Yes
    Yes
    Yes
    Yes
    No
    Yes
    Yes
    Yes
    No
    Yes
    No
    Yes
    Yes
    Yes
    Yes
    No
    Yes
    200
    14
    2
    Max3D
    Yes
    Yes
    Yes
    Yes
    No
    Yes
    Yes
    No
    Yes
    Yes
    No
    Yes
    Yes
    Yes
    No
    Yes
    No
    0
    13
    3
    CryENGINE 3
    No
    Yes
    Yes
    Yes
    Yes
    Yes
    Yes
    Yes
    Yes
    No
    No
    Yes
    Yes
    No
    Yes
    No
    Yes
    No
    12
    4
    Unity Pro
    Yes
    Yes
    No
    No
    No
    Yes
    No
    Yes
    No
    No
    Yes
    Yes
    Yes
    Yes
    Yes
    Yes
    Yes
    1499
    11
    5
    C4 Std
    Yes
    Yes
    No
    No
    No
    No
    Yes
    Yes
    Yes
    No
    No
    Yes
    Yes
    No
    Yes
    Yes
    Yes
    350
    11
    6
    Xors3D
    No
    Yes
    Yes
    Yes
    No
    Yes
    Yes
    Yes
    No
    Yes
    Yes
    Yes
    Yes
    No
    No
    No
    No
    100
    11
    7
    Chrome 4
    No
    Yes
    Yes
    Yes
    No
    Yes
    Yes
    Yes
    Yes
    No
    No
    Yes
    Yes
    No
    Yes
    No
    Yes
    No
    11
    8
    Torque
    Yes
    Yes
    No
    No
    No
    Yes
    Yes
    Yes
    Yes
    No
    No
    Yes
    No
    No
    Yes
    Yes
    Yes
    1000
    11
    9
    Esenthel
    Yes
    Yes
    Yes
    Yes
    No
    Yes
    Yes
    Yes
    No
    No
    No
    Yes
    Yes
    No
    Yes
    No
    Yes
    7000
    11
    10
    Ogre3D
    Yes
    Yes
    No
    No
    No
    Yes
    Yes
    No
    Yes
    No
    Yes
    Yes
    No
    No
    Yes
    Yes
    No
    0
    10
    11
    Irrlicht
    Yes
    Yes
    No
    No
    No
    Yes
    Yes
    No
    Yes
    No
    Yes
    Yes
    No
    No
    No
    Yes
    Yes
    0
    10
    12
    Flow3D
    Yes
    Yes
    No
    No
    No
    Yes
    No
    No
    No
    Yes
    Yes
    Yes
    Yes
    No
    Yes
    No
    No
    50
    9
    13
    3D Game Studio A7
    No
    Yes
    No
    No
    No
    Yes
    Yes
    Yes
    No
    No
    No
    Yes
    Yes
    No
    Yes
    No
    Yes
    199/899
    9
    14
    MiniB3D
    Yes
    No
    No
    No
    No
    Yes
    No
    No
    Yes
    Yes
    Yes
    No
    No
    Yes
    No
    Yes
    Yes
    80
    9
    15
    Ninfa3D
    Yes
    Yes
    No
    No
    No
    Yes
    No
    No
    Yes
    No
    Yes
    Yes
    Yes
    No
    No
    No
    No
    0
    8
    16
    Truevision3D
    No
    Yes
    Yes
    Yes
    No
    No
    Yes
    No
    No
    Yes
    No
    Yes
    Yes
    No
    No
    No
    No
    150
    8
    17
    Nuclear Fusion
    No
    No
    No
    No
    No
    Yes
    Yes
    No
    Yes
    Yes
    Yes
    No
    No
    No
    No
    No
    Yes
    59
    7
    18
    Blitz3D SDK
    No
    No
    No
    No
    No
    Yes
    Yes
    No
    No
    Yes
    Yes
    No
    No
    No
    No
    No
    Yes
    100
    6
    19
    Blitz3D
    No
    No
    No
    No
    No
    Yes
    No
    No
    No
    Yes
    Yes
    No
    No
    No
    No
    No
    Yes
    100
    5
    More rows and columns still coming... You can suggest what other engines you want on the list, but please provide the column infos, as I own/know only these engines. I'm more interested in higher rank engines though, as there are tons of lower ranks engines on the market, but I will still add low rank engines too, if I got all info for them.
    Explanation of the columns and their relevance:
    OpenGL Support: This feature is important for people who want to make cross-platform 3D development.
    Basic Dynamic Shadows: Basic or incompletely implemented Dynamic Shadows. Some engines don't have point light shadows, some have only stencil shadows.
    Full Dynamic Shadows: This means that all lights cast realtime shadows on all 3D objects, including self-shadowing, which means that a 3D object casts also shadows on it's own surfaces, and not only on other surrounding 3D objects. Also PoM shadows (=shadows from 3D textures) are needed to qualify as a Full Dynamic Shadows engine.
    256+ Dynamic Lights: This is only possible with deferred rendering capable engines. The alternative to deferred rendering is forward rendering, which allows only around 128 dynamic lights (using a 128 buffers hack) due to color overburn and too low performance if you go above that. However, in most cases only 4 or 8 dynamic lights are used in forward rendering engines.
    Realtime GI: Realtime Global Illumination means light bounces, color bleeding and specular effects in realtime.
    OGG Sounds: The Vorbis OGG audio compression format allows high quality sounds at low file sizes and streaming. Also licensing issues are important for 3D application development, where the OGG format provides a GPL free license.
    C/C++ Support: The C and C++ programming languages have been the de facto standard for industrial computer software engineering since 1972 © and 1978 (C++). The support for external standard libraries is huge, and thus saves companies a lot of time and money when developing computer software. They create also the fastest applications.
    Realtime Scripting: The engine can be controlled using a script language, and scripts can be changed on the fly.
    Source Code Included: The engine comes with its source code. Many engines have also a seperate Source Code license, which can be very expensive.
    Entity Based System: This means that everything in the 3D world is a 3D Entity (sounds, cameras, models, pivots, lights, emitters, etc...), which can be controlled with the same commands like MoveEntity, ScaleEntity, TurnEntity, HideEntity, ShowEntity, etc...
    Entity Based Systems provide an easy learning curve, and powerful operations with simple commands, since no academic 3D matrix math is needed to be learned by the user.
    Alternatives to an Entity Based System is a Node Based System or a Tree Based System.
    Low End Support: This means basically that the engine can run with any existing graphics card.
    High End Support: This means that the engine supports modern AAA 3D technologies, and requires a SM3/SM4 capable graphics card.
    Physics: The engine has physics built-in and integrated.
    OpenGL Commands: The user can freely program in OpenGL language on top of the engine's 3D rendering. This is normally needed only for special purposes, like for example drawing 3D lines in the 3D space. Usually the engine renders 3D graphics much faster due to its internal optimizations.
    Realtime Editor: The engine has a native or 3rd party with plug-ins 3D Editor which shows the results of editing in realtime.
    Cross-Platform: The engine runs natively at least under MacOSX or Linux.
    Price under $1000: A point is given if the engine costs $1000 or less.
     
    Source
  23. Canardian
    Since the end of life of Notes/Domino 7 is coming in 2011-04-30 according to Ed Brill: End of Life for ND7, it's a good time to review the benefits of the two best Web Database platforms available on the market today: LAMP (=Linux Apache MySQL PHP) and Domino.
    1) LAMP database design can be edited with any text editor remotely, even with vi via secure shell (SSH). Domino Designer 7 and Notes 7 work fine, but not Domino Designer 8.5 or Notes 8. Domino Designer 8.5 is written in Java and is thus ridiculously bloated, slow, buggy and exposes lots of security holes.
    Notes 8 crashes when opening documents which contain HTML code, while the same document opens fine in Notes 7 and Notes 8.5, although some of them crash also Notes 7, but Notes 8.5 doesn't crash on any of them. Android got rid of Java in their OS, and users are praising the smaller memory footprint of 30MB and the incredible raise in speed due to native C++ code. OpenOffice uses Java also, and is a bit slow, but by miles not as slow as IBM's Java engine, which you can experience with Domino Designer 8.5, Notes 8.5 and Symphony.
    Although many things can be done with a graphical design in Domino Designer, the graphical features need to be replaced with LotusScript code when the application needs more features and customization. If you've ever worked with a simple application ready web server like Quickr, Sharepoint or Ruby On Rails (which are all horribly slow and inflexible compared to LAMP or Domino), as a developer you will love systems which are exactly the opposite and have thus full programmability and speed, and easy customization support, even if they don't have any ready apps.
    Hmm, actually this is a good question why does Domino not have any ready apps, or does it, if you count openntf.org? It's just not marketed as such by IBM. I think IBM should understand what collaboration really means, it means that the community does eventually official things, and not only IBM. A half point goes to LAMP.
    2) LAMP combines HTML and server side code in the same php document. This makes coding very easy and convenient, while in Domino Designer you need to juggle with a WebQueryOpen and WebQuerySave agent, which usually needs then more code and visual design elements to handle all different situations - you have to place additional fields in the Form and address them in the LotusScript code.
    This point is a draw though, since in LAMP you need to code everything, while in Domino Designer you can avoid some coding, and despite that it usually needs some more effort later on, it also saves time.
    3) The Domino 8.5 server has had known and fatal bugs for years, and although IBM knows about them, they haven't been fixed. One of those fatal bugs is for example that LotusScript WebQueryOpen agents keep running forever, until the memory is full, when the user closes the browser. The only workaround is to make a HTTP restart every night. In Domino 7 this problem does not exist.
    Another fatal bug is that chronos.exe crashes the server, however this can be fixed by deleting chronos.exe (speak: move it to a backup subdirectory, as you might need it for the next incremental installer), as it is some remain from Domino 1.0 where it also crashed all the time. And a third fatal bug is that compact increases the database size. This works fine in Domino 7. And a fourth fatal bug is that DAOS enabled databases with attachments cannot be copied to a Local file system when they are restored to a backup server first. This works also fine in Domino 7, since it has no DAOS.
    Domino 7 vs LAMP would have been a draw, but since businesses are forced to upgrade to Domino 8.5, this point goes to LAMP, as it has no such fatal bugs. In a similar situation, where Microsoft's Windows Vista was a plain failure for businesses (there was no business need or even benefit to upgrade) and Windows 7 (better than Vista, but it made itself required by ending the OEM Windows XP support), there is still support for Windows XP until year 2020, because that is the end of life of Windows 7 and the Windows XP downgrade is part of Windows 7, so it extends the end of support of Windows XP equal to the end of life of Windows 7. I find it a bit ironic that Microsoft has now better backwards compatibility, while this was the ace card of IBM over Microsoft for decades.
    4) LAMP is open source and free, while Domino 8.5 is closed source and commercial only. Android won iPhone, Sony/Ericsson and Nokia because it is open source and free. Likewise, the importance of a free version of Domino is to get a bigger market impact and get it more supported. This point goes to LAMP.
    5) LAMP works on 12 hardware platforms, while Domino works only on 5. An important version is the 64-bit Linux version on Intel and PowerPC, and Domino doesn't have them either: FAQ: 64-bit version of Domino This point goes to LAMP.
    6) Readers and Authors type fields and Groups and Roles are a major benefit of Domino. This point goes to Domino.
    7) Love for Lotus and the visual development environment keeps the developers motivated. This point goes to Domino.
    As it stands now, LAMP wins Domino 8.5 with 4.5:3.
    LAMP vs Domino 7 would have been only a 4.5:4 win.
     
    Source
×
×
  • Create New...