Still a ton to do, but I'm really digging it.
Edit to add: WASD + Space/Shift + arrows to control the camera.
That said, the tools are unbelievably slow and will be rewritten in C# once things are functionally complete. Python just allows for very, very rapid development of this sort of thing (for me).
 http://symbolflux.com/statichtml/oldprojects/md3library.html (No source or anything available atm—just a screenshot and description, though I could up it up if anyone were interested.)
MD3 has been pretty straightforward on the whole, but I didn't design my mesh abstraction super well out the gate, so I've mainly been redesigning that and trying to make it futureproof. I think I have it to about the minimum repeated code possible at this point, but I'm sure I'll reach some other snag down the road and have to refactor again!
This brings back memories. I wrote a MD2 loader for my final project in my 3d graphics elective in college years ago. It was a ton of fun. Quake 3 came out my freshman year, the format wasn't very well documented yet but MD2 had tons of documentation.
Can't comment to how much easier / harder level loading would be but I'd venture to say probably much easier. Characters have more animation and such along with them.
System.Exception: TypeError: Cannot read property 'viewport' of null
at ctor.Resize (http://demoseen.com/bridge/WebArena.js:180:37)
at new ctor (http://demoseen.com/bridge/WebArena.js:158:22)
at Function.Main (http://demoseen.com/bridge/WebArena.js:119:13)
at HTMLDocument.delayfn (http://demoseen.com/bridge/bridge.js:481:21)
at HTMLDocument.listenHandler (http://demoseen.com/bridge/bridge.js:498:30)
From 10 years ago, how they did the (mostly automated) managed port of Quake II :)
Didn't know about Bridge.NET. That's way cool, how is it from a development perspective?
In short, I guess it would basically be like selling RPG Maker games or DOOM wad's, but without the engine itself being proprietary.
Mind, this is a game, not an "engine". And I'm okay with that; building an "engine" rather than building an actual game is something that we OSS nerds are already prone to self-nerdsniping on, and the resulting engine-with-no-game doesn't really help anyone (including, typically, other game makers, because without a single trial-by-fire, that "engine" code tends to be pretty useless). It's good that it's OSS, even if (and especially if?) it's not an "engine".
Perhaps there is no standard engine in the FOSS world because the engines are not advertised as strongly as the most popular commercial ones. Unity, after all, will gladly let you know it's being used whenever the game starts.
PS. Of course one could claim you can never be certain of those (hacking disassembled code is always an option) but in any way you look at it, if you do have the resources to have your own engine you retain more control.
I'm sure you could argue that Unity is currently more cross-platform than engines were 10-20 years ago and already works on Mac/Win/Linux/Android/whatever, but we can't guarantee it will be around in 20 years.
There are really very few practical limits there. You can distribute a game with a modified engine. But what the poster was talking about was a common engine with source that will be around for a long time. UE sounds like a fairly close match. Maybe they had something else in mind but 'the ideological is the practical and vice versa so this ain't nothing' seems more like some sort of odd logical (ideological?) contortion than an argument.
Another very practical limit is that you can only distribute changes to the engine through either Epic's marketplace or a fork of their GitHub (so you cannot distribute changes through your own website, for example).
Also you cannot make a modification to the engine itself (even through the "allowed" means) and distribute it yourself as an alternative version/fork of the engine.
Finally, yet another very practical limit, is that you cannot take source code out of the engine for use in other engines and products - no matter what.
All these are practical - not ideological - issues that proper open source projects do not have. Unreal Engine is not open source, you just have access to the engine's source code for minor and project-specific modifications and even that comes with several limitations as i already mentioned above (and there are others tool, just read the engine's EULA).
I really appreciate him making that available, fantastic little cautionary tale, clearly from an enthusiastic and thoughtful learner of Java - glad he's made good progress since then, though, that's... I mean, dang it is REALLY bad, but it is also amazing as a sort of exercise in him just knowing what he wants to do and finding (bad) ways to make it happen. And that's admirable, even if it is also horrifying to see unfold. :D
I know there are many programmers that spend long hours recreating games they like in open source. But are there artists doing the same? It would be great if many of these projects that require a copy of the original game for the assets could get contributions from artists willing to make open source skins / texture packs as well.
Cloning an existing game is easier.
Of these, Star Control (Ur-Quan Masters) is also one of the best games with tear-dropping story which I also recommend highly. The open-source port is of excellent quality.
HTML5 and browsers are becoming performant enough. Is there some other portable emulator that might be a better target?
Supports a lot of the Quake based games (started out as a QW engine but is much more today).
Had Vulkan support way earlier than vkQuake came to be. Spike, the basically single developer behind it is really talented.
We've had a reverse-engineered server for some time: https://bitbucket.org/grelminar/asss
Doesn't seem much different to me to e.g. writing an open-source game that uses DirectX. DirectX is not, itself, open-source, but it's not really "part of" the game. The game just uses its API; and could equivalently use anything else with the same API (like the DirectX implementation in Wine.)
Depending on a closed-source engine at all by definition makes the game not open source, when you consider "the game" from both a developer and user point of view.
If some of a program's dependencies are nonfree, this means that all
or part of the program is unable to run in an entirely free system—it
is unusable in the Free World. Sure, we could redistribute the program
and have copies on our machines, but that's not much good if it won't
run. That program is free software, but it is effectively shackled by
its nonfree dependencies.
I would consider neither Unity nor Unreal capable of producing free software titles because there is no way to get the engine parts without some barrier. It may not be monetary, but you still need to agree to EULAs for both engines, despite the later being nicer since it also includes source access.
An open source game does not, however, need to start from scratch (which saying OpenGL seems to imply). There are both legacy code bases like doom3 or free engines like Godot that let you build off them rather than reinventing all of the extremely complex and sizable code required to even start making a video game.
It is just you cannot have open code that is then tied to a proprietary part unless that proprietary bit has liberal distribution rights (and I don't mean just the game lib you ship, you need to be able to recompile the project with changes which almost always means you need the game editor). I'm not aware of any proprietary engines that give away all the tooling under permissive terms that would fit that scenario, though.
Also, I used OpenGL in my example because the parent post used DirectX. I also agree with you that they don't need to start from scratch, despite what you said, I did not imply they did. I was simply replying directly to the parent reference to DirectX.
Nobody ever says that a program being written for closed-source hardware necessarily implies that the program can't be open source. Because, of course, you can just write your own open VM for that same hardware. Saying that e.g. Gameboy Advance home-brew is all closed source, because the reference implementation of the hardware is closed source, is nonsensical. People are free to write, modify, and run GBA home-brew. Doing the last one just requires an emulator for most people, which is an everyday tool for programmers (given that many languages target abstract machines like the JVM or Erlang's BEAM, where the resulting bytecode ISA is only reified as an emulator.)
In that particular case, DirectX is a set of APIs provided by the OS vendor to develop games on their OS. It's part of Microsoft's platform.
In the GBA's case, Nintendo's platform is the hardware and their SDK. If I'm remembering correctly, there's an open SDK to replace Nintendo's, because the latter isn't (legally) available to homebrewers. But, the libraries linked from the SDK are universally distributed with the game. If someone wrote homebrew on the Nintendo SDK, I'd say it's impossible for it to be "open", because not everything that is distributed as part of the game is open.
Going another direction, with a specific example: The entire "business logic" of the game Dark Forces: Jedi Knight II is available as source. Literally, human-readable scripts packaged in a trivial archive format. Just have to write the engine, right?
I think this comes down to a particular design decision of the GBA homebrew SDK (https://github.com/devkitPro/libgba) to not be ABI-compatible with the official SDK.
Consider, as a contrasting example, C#. Microsoft's official SDK is closed source. Mono is open-source. But Mono's runtime libraries are ABI-compatible with the official runtime libraries.
In the case of the GBA, you'd expect/require a binary release to be "shipped with" the official runtime libraries linked in. But with C#, you don't expect that; you just expect to receive the binary containing the individual business logic, and then use the runtime library you have available (Microsoft's on Windows; Mono everywhere else) to run it.
> The entire "business logic" of the game Dark Forces: Jedi Knight II is available as source. Literally, human-readable scripts packaged in a trivial archive format.
I would say that this is open-source, yes. Consider the case where someone uploaded, say, the "business logic" (and assets) of an RPG Maker game, back when ASCII/Enterbrain's own runtime was the only one available. Now there are plenty of open, ABI-compatible interpreters. So this is at least open-source code now, no?
Or, for another example, consider original-Doom .wad files. If you released one of those back in 1993 under a GPL license, it might not mean much—but today there are open DOOM clones for literally everything. One difference here is that those interpreters don't have Doom's original IP (asset packs) included in them; they expect you to add them in. But does that make the .wad file itself less open as a product? Not everything needs to be standalone. You could have an open-source expansion or mod for a closed-source game. You can interpret a level or level-pack in just such a manner.
I think it comes down to the fact of SDK libraries being statically, and inextricably, linked into the ROM.
> [about DF2:JK] I would say that this is open-source, yes.
I'd say it isn't. First, the license is just as closed as the rest of the code. Second, it's not "the game" unless there's an engine to pair the data+code elements with. And since there's no open engine to go with the closed-but-readable code, I wouldn't use the words "open source" with any part of it.
> So this is at least open-source code now, no?
If an open engine is available, then the combination of the open game logic and open game engine would be open. Otherwise you could say "An Open engine for X" or...well, a nicely-packaged way to describe open game assets on a closed engine would be called "a mod for X" or a "total conversion", I suppose.
> But does that make the .wad file itself less open as a product?
The .wad itself could be open, but it's not "a game". It's a set of game assets. Pair it with an engine, and it's a game. Pair it with a different engine, and the same assets might be a significantly different game. The whole wad+engine game couldn't be open until at least late 1997 when the Doom source was released.
> But with C#, you don't expect that; you just expect to receive the binary containing the individual business logic, and then use the runtime library you have available (Microsoft's on Windows; Mono everywhere else) to run it.
Right. C#, Java, etc are expected to have an external, completely separate runtime as a dependency. When there isn't an open runtime available, it's the situation that used to be called something like "the Java trap".
This is a very strange interpretation.
When a piece of software that is released under a free license has a crucial non-free dependency, it is effectively non-free. As the software only works with the non-free dependency, but that dependency cannot be conveyed along with the free part, the whole thing cannot legally be distributed and thus is non-free.
Consider: there are also hardware platforms that have effectively ceased to exist over the years. If you wrote a program for one of these platforms, and it was open-source, would you now consider the program closed-source, because—given that the platform hardware doesn't exist any more—you can't run the software any more?
No. Why not? Because open source is about the source, not about the binary. The source is a product in its own right, and valuable in its own right, whether or not it can be compiled into a working program.
If you have the platform and the source, but you can't run the program, then I wouldn't consider it "open source". At least not in the usual sense of FOSS. It's not just about the source; it's about the freedom to study and modify the source, produce improved versions of the original binary, and distribute that binary and the source that created it.
The division between game and platform is lower in the stack than the engine.
> The source is a product in its own right, and valuable in its own right, whether or not it can be compiled into a working program.
I agree with that statement, but it's a different argument than you were making before.