Made a gamejam game
https://www.youtube.com/watch?v=ujVWm9kqq5Y
It's a party game. It's kind of like Robot Wars mixed with Super Smash and added input delay. There's a (1.5 s) delay in the beginning that actually gets closer to 0 the more you get hit. That way, you are more vulnerable after each strike, but you also have better reaction times than your opponent. It's pretty fun actually.
started to work on my own site now as a portfolio with hugo.
Do someonehave a cool hugo ebook for learning?
I don't like how current video editors function or handle media, so I've decided to create my own. The popular video editors Vegas Pro and Adobe Premiere are both based on QuickTime, which struggles with compatibility with modern media. Vegas Pro especially struggles with modern performance. There's Kdenlive too however I'd label it as unusable with how unstable it is.
Advantages I automatically have out of the box are greatly increased compatibility, FFmpeg can pretty much open and write everything on the planet. I also have frame accurate seeking which other programs struggle with. Performance wise I'm utilizing the GPU for relevant tasks so that's stupidly fast.
There's still a way to go, but progress is going good. I have taken a lot of screenshots and videos throughout the development but here are the two latest videos.
https://streamable.com/mbbb1
https://streamable.com/2n2in
I noticed the compatibility problems with modern video while developing my other project Source Demo Render. I learned a lot about media while making that.
You're an awesome dude. Don't give up on this project.
Any plans to release it? I'm very interested in a decent modern video editor.
Bring it on github @crashfort this project is awesome o.O!
Remade my native CinematicTools for Venice Unleashed / Battlefield 3.
Usually you would have to manually edit and add these values in the source. You would make some changes, recompile and see if anything changed. Now everything is realtime, with full save/load support and the ability to add states on top of each other, so we can have multiple presets at once.
http://powback.com/u/b8479e92379a86bd3ffba93844d10a45.mp4
I threw out my cartoony clouds and instead made a system for rendering billboard-based volumetric ones. Rendering transparent objects like this in VR can be quite a pain so I spent a lot of time making sure they performed well. Rather happy with how they turned out!
https://puu.sh/zcjkE.jpg
I spent most of my weekend working on a similar system, but only made it as far as really just contemplating the design, architecture, and how shaders will eventually be written. I had hoped to write more than the little shader fragments I got to, but didn't want to rush the design. Have you considered compiling your monolithic shaders once used to SPIR-V, and saving that to file with a unique hash ID made up of the snippets an ubershader uses? That way you can load those from disk and not have to recompile, plus avoid the issues with the whole "GLSL requires a driver to implement a GLSL compiler" thing. Might even be able to pre-generate your most common permutations ahead of time.
You can also use tools like SPIR-V cross, shaderc, and glslang even if you don't end up using SPIR-V - but they can be useful for validating shaders, performing reflection on shaders, or in the case of shaderc (iirc) doing an optimized SPIR-V compile of your shaders
I was under the impression that there was no alternative ways to work with shaders; that all one could do is 1) fetch shader stages from disk 2) compile stages 3) link stages->program
I'm gonna google some of the terms in your posts, because from the sounds of it I have a lot of things to learn
https://files.facepunch.com/forum/upload/108652/e7dc10a2-e713-4ef5-9761-acc659322713/IdQkp2.png
I am creating my own engine management unit for a 1980s two-stroke racing motorcycle (hardware and software), it handles the RPM measurement on the crankshaft, speed measurement on the front wheel, spark ignition and retardation/advance based on the throttle input and RPM, rev limiting and launch control.
I'll also have to read the racing rules in detail and make a throttle body with fuel injection if it's legal to squeeze that extra power out of the engine before changing the cylinder head geometry.
Spent like 10 hours working out a printf exploit for an assignment. Thank Christ for %hhn, but god mucking around memory is a bitch.
I took some cool images about my game only to find out that the anti aliasing was disabled, they looked super bad like this
https://cdn.discordapp.com/attachments/369257919331696640/407688495092727808/unknown.png
This one is with x8 antialiasing, looks far better now. I'm dumb
https://cdn.discordapp.com/attachments/369257919331696640/407688563317276674/unknown.png
I accidentally recreated delegates in C++ using std::variant.
My work application used to have commands given to satellites at various time periods - it wasn't horrifying, but it was less than ideal given that this was the command type:
typedef struct {
Number time;
C_Satellite* theSatellite;
en_Action action;
C_Satellite* target;
Number a,b,c,d,e; //holder registers
int tip;
} Command;
// as a note, yes this is the original indentation style and yes it was this bad EVERYWHERE
So different action types had different uses for the A,B,C,D parameters but it was not clear what each meant. That and writing a command in original simulation file format went like so:
int_CommandNumber 1 // indexing from 0 is for scrubs
num_CommandTime 1 1 0 // the command number is referenced as the first param, not sure what the second/third are for
str_CommandAction DEBOOST 1 0 // pretty sure second param is command number again. not sure on third.
str_CommandCommandeeType TETHER 1 0 // for some reason we give a type of the commandee too
int_CommandTetherIndex 1 1 0 // i think the format is (tether_idx) (command_idx) (mystery number). Still indexing from 1 :c
num_Command_a 0 1 0 // not sure wtf this is supposed to do, even checking the code that reads this line
So yeah that wasn't really ideal. The intent of the new JSON system is for a command to be listed in a "commands" array like so:
{
"commands" : [
{ "Type" : "Thrust"; "Commandee" : "MySatellite"; "ThrustLevel": 80.0; "ExecutionTime" : 3000.0; },
{ "Type" : "Release"; "Commandee" : "MyTether"; "ObjToRelease" : "MyPayload"; "ExecutionTime" : 3200.0; }
]
}
... and so on. The improvements being - refer to objects involved in command execution by name, use named parameters, and don't worry about any of that indexing bullshit.
To accomplish this, I defined a unique struct per command type. Each struct stores the relevant parameters - objects being stored as pointers, which are retrieved from the sim-wide objects map and set on import (commands are last thing imported). Each struct also has "operator()()" overloaded, since I store commands like so:
using Command = std::variant<Thrust,Capture,Maneuver,Release,RendezvousWith,AdjustOrbit>; // etc, for rest of command types
std::map<Number, Command> commands;
At first I had some silly setup where all the commands inherited from a base command class holding the names of objects (retrieved as needed from the object map), the time of execution, and so on. Then I defined some function for doing what each command specified as a free function in the sourcefile of the "CommandList" class. After doing this though I realized 1. derived types seemingly don't count as unique types to std::variant 2. I was still not really evolving much from what was previously implemented (previously the unique code per type was just in-line in the switch statement handling each potential case) 3. I could just std::visit with my variant if each structure defined "operator()()".
So that's what I do now. At each timestep, I check to see if there's a command that needs to be executed or if the next timestep will cause us to miss a command. If either occur, we choose to execute the command. That's done by literally just the following lines:
auto& cmd = commands.at(next_command_time);
std::visit([](auto&& args) { args(); });
So now there's no more nasty inline code inside a fairly lengthy switch statement, no need to define unique individual functions independent of a command type itself, and the actual execution is a one-liner. Neat.
But I also could have literally acheived the same with a delegate class, using the arguments and type from the JSON to choose the right function pointer and function arguments to store. So not really sure how to feel about this. I can't see any unique advantages of this approach, and it has the disadvantage of required what are effectively just wrapper structures over commands already integrated in the programs classes. The structures themselves are really just explicitly declared/specialized delegates so uh yeah, oops?
Implemented a billboard-based LOD system for my clouds. Now I can render tons of them at really great distances!
https://www.youtube.com/watch?v=fPINb9oCfS8
... Is this MSAA ?
It's supposed to look pretty much perfect at 8x, however:
https://files.facepunch.com/forum/upload/133076/efad2eaa-8e1c-4f69-be07-32bbff0cd5d4/image.png
https://files.facepunch.com/forum/upload/133076/9d107425-b77d-4ca9-8379-4c8f8336b3e6/image.png
That's not pretty at all. Are there transparent surfaces in those areas ? If you're using basic deferred rendering, it can't do much about this.
yeah the game still needs more love on the graphics side. I was using deferred rendering until I found unity disables anti-aliasing if you don't use forward rendering so for now it looks far better than older images but of course it needs more tweaking, its not a final build
Try using fxaa then. It's a post-processing type of anti-aliasing you can use with deferred rendering.
Can you do anything to make the transitions not as jarring?
Hey, someone mentioned there being a discord and linked an invite (which has now run out), is there a permanent join link or can someone post another?
Sorry didn't click set don't expire.
Discord
So the good news today is that the patch I wrote for our flight hardware's control board (payload heading to ISS) worked on the first try. I don't entirely believe that (really don't), but it was simple so maybe it happened. I had never done networking stuff before, and this was also embedded dev for a hardware/firmware combo I've never used. So that was the good news
The bad news is that my boss / CEO of our company told me for the fifth time that he has a teleconference with a NASA flight center a little less than 12 hours ahead of time. That and the code I keep trying to refurbish finding new ways to break (everything thought it was in the sun for doing sun-related math) means I kinda had to stop myself from putting my two weeks in
Don't know where else to go though, not a lot of places hiring Vulkan devs and that's what I'd really love to do if I wasn't doing space stuff
It's a tricky problem. I've tried doing bilinear blending between the 4 closest samples but that ends up rather blurry. Something that seems more promising is doing "reverse" snapping with the quad's rotation = rotating the quad in the opposite direction of the camera direction until the billboard snaps to another texture rect. In theory this should match the two samples better when switching, but I found it easy to implement for one axis and rather difficult for polar coordinates.
It's also worth bearing in mind that the camera won't move that quickly in the actual game, though it certainly would be nice to fix the popping.
I've been away for a while. Got laid off from the job I'd been preoccupied with for the last few years and now I'm back to working on an old project. Almost done with Uni, too!
It's the first thing that I've ever built that seems worth stealing, so no details until I'm almost finished. I've kept a folder of screen captures to edit together into a big video when I'm done.
What's the deal with the whole programming subforum being on a new URL and theme? When did that happen?
Couple of weeks ago
new version of facepunch, slowly being rolled out
old accounts didn't transfer per say, but you can use the built in tool to join your old account into your new one.
Some sections of the old site have transferred, such as this one.
Made a video breaking down my scene lighting/clouds etc:
https://www.youtube.com/watch?v=uf-3L8QfIa0
At this point I am satisfied with the way the world looks, so I am going to move onto other areas of the game such as the aircraft.
(huge jif warning)
https://imgur.com/a/P6yKU
Anyway, I'm too ill to do anything proper so i've been working on a few bits and bobs here and there. The latest bit and bob is to do all the gpu physics simulation i've been meaning to do for a million years
Getting navier stokes in was surprisingly straightforward, i ported over the gpugems solution. I'm aware that jacobi iteration isn't too grand performance wise, so if anyone knows a good relatively drop in replacement that'd be helpful
Getting the fluid particle simulation stuff to work was significantly harder. Each particle does a bresenham line draw between its current position and its destination looking for blockers and other particles, and moves to the furthest along particle
Lots of particles end up inside each other in a parallel simulation, so there's a simple decision rule: if your gid is less than the one you found on the particle texture, move upwards if possible
On top of that, you need to define a consistent global ordering for hole filling otherwise you end up with filling loops, although this is not exclusive to a parallel simulation (although it not being simple falling sand exacerbates it). I had to split the world into chunks and give each gpu thread ownership of one (2x2) chunk, so they could update it in a pseudo single threaded wqay
The other humongous pain was dealing with the particle <-> fluid interaction. Having the fluid blow around the particles is easy when you have a velocity map, you just pos += velocity * timestep. In this case though, clumps of particles actually resist fluid flow to some degree. Initially i actually constructed a no slip boundary condition around the edge of the particles (neat), but it was difficult to make this a 'soft' effect which allowed *some* fluid penetration
In the end, the solution i settled for was having particles subtract fluid velocity from their current position depending on how many pixels are surrounding them. The more pixels around them, the more they subtract every frame. This means that as a wave of fluid enters a group of particles, it'll be gradually damped instead of being hard deflected which is nice
https://github.com/20k/fluid_sim
(also newpunch sucks and is about 50% of the reason i don't come here anymore, privacybadger has blocked 22 tracker services and ublock is blocking 24 ads, WTF is going on, its slow as all tits)
Stop making cool shit you're making the rest of us look bad.
JK aha, thats pretty badass. The only thing I can think of, is that clouds move over time :P.
Sorry, you need to Log In to post a reply to this thread.
What are you working on? v67 - March 2017
