What are you working on? - Developers

[img]http://i.imgur.com/38rALeX.png[/img] Wrote a ghetto Valve Keyvalue parser in Perl that outputs JSON, because nothing else I found simply printed to stdout Now to write another program that makes sense of the data.

Who do I need to contact, if I want a custom icon for the post user agent icon? I think it could be fun to see who posts from my app.

Robotboy perhaps maybe.

[QUOTE=geel9;49965010]...[/QUOTE] Apparently the Teensy 3.0 also supports OTG. That's pretty much as easy as it gets.

Shit, procedural voxel world generation is harder than I thought. Might need to do some research when it becomes necessary. I recall the Minecraft devs tweeting about this extensively in 2011.

[QUOTE=Map in a box;49965663]or question why you're using an rpi for this anyway[/QUOTE] Because it's a hobby project and I can use whatever I want for it? [editline]19th March 2016[/editline] also because the teensy doesn't allow me to plug an xbox controller INTO it and I'm not about to go splicing wires to do that shit. the pi allows me to read xbox controller input and output a PWM signal for the motor controllers.

[QUOTE=geel9;49966516]Because it's a hobby project and I can use whatever I want for it? [editline]19th March 2016[/editline] also because the teensy doesn't allow me to plug an xbox controller INTO it and I'm not about to go splicing wires to do that shit. the pi allows me to read xbox controller input and output a PWM signal for the motor controllers.[/QUOTE] Just get an OTG cable

[QUOTE=Topgamer7;49963683]So what you're saying, is that you couldn't use gdb to debug gdb debugging your roguelike? :D[/QUOTE] Aaand you're a terrible NPC now, too.

GLSL spirograph generator thing: [url]https://www.shadertoy.com/view/XstXz7[/url] [img]http://i.imgur.com/lmi4Ne1.png[/img] It generates distance field and "velocity field" textures in a separate buffer and uses them to do the shading. [t]http://i.imgur.com/1BiuekS.png[/t] [t]http://i.imgur.com/bVaUwY9.png[/t]

Alright, now we can play videos and image files in-game. You know what that mean, ladies :cat: They resizes themselves, and rotate gradually to face you. Somehow, listening to music, watching videos and pictures in games always feels more fun than doing them directly. [video=youtube_share;-TxJTQGQ_8Q]http://youtu.be/-TxJTQGQ_8Q[/video]

In OpenGL, is the uniform location ever negative? It makes no sense that all other identifiers are unsigned but the uniform location is signed for some reason. Even attribute location is unsigned. As far as documentation goes, it says that the attribute location returned is signed because -1 signifies an error, but all the functions that use that location take an unsigned value. For uniform location it also says that -1 is an error, but the function that take a location also take a signed value. Does that just mean that they can handle a -1 or does it mean that a uniform location can actually be valid AND negative?

Doesn't uniform just means global value? Same for every vertex/pixel thread.

[QUOTE=hakimhakim;49970263]Alright, now we can play videos and image files in-game. You know what that mean, ladies :cat: They resizes themselves, and rotate gradually to face you. Somehow, listening to music, watching videos and pictures in games always feels more fun than doing them directly. [video=youtube_share;-TxJTQGQ_8Q]http://youtu.be/-TxJTQGQ_8Q[/video][/QUOTE] Instead of using fraps, you should/could use [URL="https://obsproject.com/"]Open Broadcaster[/URL] or maybe [URL="http://www.geforce.com/geforce-experience/shadowplay"]GeForce Shadowplay[/URL] if you have an Nvidia GPU. Both are free.

[QUOTE=Fourier;49970413]Doesn't uniform just means global value? Same for every vertex/pixel thread.[/QUOTE] It does. What does imply? I'm specifically talking about the uniform location you get from glGetUniformLocation

[QUOTE=hogofwar;49970475]Instead of using fraps, you should/could use [URL="https://obsproject.com/"]Open Broadcaster[/URL] or maybe [URL="http://www.geforce.com/geforce-experience/shadowplay"]GeForce Shadowplay[/URL] if you have an Nvidia GPU. Both are free.[/QUOTE] I believe AMD have a ShadowPlay equivalent too (the word Raptr comes to mind immediately?) - recording footage these days is very easy. [QUOTE=Darwin226;49970639]It does. What does imply? I'm specifically talking about the uniform location you get from glGetUniformLocation[/QUOTE] I've never experienced uniform locations being negative and valid; the only negative value I'll ever get is a -1 if I got the uniform name wrong in application code. Trying to use a negative value of any type in a GL uniform call results in an error.

[QUOTE=Darwin226;49970639]It does. What does imply? I'm specifically talking about the uniform location you get from glGetUniformLocation[/QUOTE] I'm fairly certain it will only give zero or positive numbers for valid uniform locations, but as long as the specification doesn't say otherwise, any negative number other than -1 is theoretically valid too. You really should just treat these values as opaque handles though (and check with [I]== -1[/I]), which makes it completely inconsequential whether they're positive or negative. [editline]20th March 2016[/editline] [QUOTE=jonnopon3000;49970641][...] Trying to use a negative value of any type in a GL uniform call results in an error.[/QUOTE] I'm pretty sure this is also precisely the reason those parameters are signed: You can put the invalid value you got previously into the new function and it will error correctly. It's easier to debug if you get "invalid uniform location" when you make this mistake rather than "no uniform at 0xffff" (or however wide the value is).

Bit of an off topic question, but seeing as a few people here have used SFML seems like the right place to ask. Has development on SFML ceased? The last commit was in October and it seems the main guy, laurent, isn't working on it anymore? Would SDL2 be the preferred way of creating ios/android games in c++?

[QUOTE=Tamschi;49970659]I'm fairly certain it will only give zero or positive numbers for valid uniform locations, but as long as the specification doesn't say otherwise, any negative number other than -1 is theoretically valid too. You really should just treat these values as opaque handles though (and check with [I]== -1[/I]), which makes it completely inconsequential whether they're positive or negative.[/QUOTE] It's just annoying that it breaks the pattern. Every other handle is unsigned...

[QUOTE=Tamschi;49970659]I'm pretty sure this is also precisely the reason those parameters are signed: You can put the invalid value you got previously into the new function and it will error correctly. It's easier to debug if you get "invalid uniform location" when you make this mistake rather than "no uniform at 0xffff" (or however wide the value is).[/QUOTE] That'd be my guess, it seems to make sense. Plus you're right about using any location value returned by OpenGL as an opaque handle. Unless I've missed something major in my work, I've never needed to explicitly check the returned value.

[QUOTE=Tamschi;49970659] I'm pretty sure this is also precisely the reason those parameters are signed: You can put the invalid value you got previously into the new function and it will error correctly. It's easier to debug if you get "invalid uniform location" when you make this mistake rather than "no uniform at 0xffff" (or however wide the value is).[/QUOTE] Yeeah but then this [url]https://www.opengl.org/sdk/docs/man/html/glVertexAttribPointer.xhtml[/url] doesn't take a signed value even though getAttribLocation returns one.

[QUOTE=Darwin226;49970689]Yeeah but then this [URL]https://www.opengl.org/sdk/docs/man/html/glVertexAttribPointer.xhtml[/URL] doesn't take a signed value even though getAttribLocation returns one.[/QUOTE] Have to say, I've never noticed. It's either a major inconsistency or a logical implementation beyond the reaches of our tiny minds. At the end of the day, locations are pretty much useful for getting, then passing onto the relevant function. As far as I can tell there's no reason to worry about its value until after you've tried to do something with it and received an error. Of course, it's likely that I'm monstrously wrong and I'd love to be corrected. Suppose I should post what I'm working on. After getting over my arrogance (and slight bout of destructive depression) with the first year Java coursework assignment at my Uni, things went well. It turns out to be a kind of "fake physics simulation" that kind of resembles a 2D version of our Universe. The task was designed to improve confidence with inheritance and production-quality code and as far as I've been told, it worked for a lot of students - which is great to know given my previous opinions. I'm also the only student on the course that completed all task criteria, including the bonus tasks of saving/loading and providing a user interface along with some debug utilities. Right now, I'm working on transforming it into an Applet (though I might just go and port it to my JS+WebGL "engine"), then I'll be re-writing as an actual physics sandbox because it'd serve as a fantastic starting point. [video=youtube;ySptlRHx3-M]https://www.youtube.com/watch?v=ySptlRHx3-M[/video]

[QUOTE=Tamschi;49970659]I'm fairly certain it will only give zero or positive numbers for valid uniform locations, but as long as the specification doesn't say otherwise, any negative number other than -1 is theoretically valid too. You really should just treat these values as opaque handles though (and check with [I]== -1[/I]), which makes it completely inconsequential whether they're positive or negative. [editline]20th March 2016[/editline] I'm pretty sure this is also precisely the reason those parameters are signed: You can put the invalid value you got previously into the new function and it will error correctly. It's easier to debug if you get "invalid uniform location" when you make this mistake rather than "no uniform at 0xffff" (or however wide the value is).[/QUOTE] If you guys are talking about uniform location as in uniform address as in uniform pointer then I am sorry, I missed the Darwins point so much.

Hmm, implemented items that can store liquids. Getting a useful an good-looking interface is tricky sometimes, but I think I got it. [img]http://i.imgur.com/hhEp9At.png[/img]

[QUOTE=Richy19;49970674]Bit of an off topic question, but seeing as a few people here have used SFML seems like the right place to ask. Has development on SFML ceased? The last commit was in October and it seems the main guy, laurent, isn't working on it anymore? Would SDL2 be the preferred way of creating ios/android games in c++?[/QUOTE] SFML is in active development and version 3 is (probably) on its way. The latest full release was indeed in October but the repo was updated ten days ago.

Made some dumb bots, very amusing. [thumb]http://i.imgur.com/VAVt93Z.png[/thumb]

[QUOTE=fewes;49971301]SFML is in active development and version 3 is (probably) on its way. The latest full release was indeed in October but the repo was updated ten days ago.[/QUOTE] Wait, whats going on with the commits, says the last one was in october, yet the one before that was 13 days ago [url]https://github.com/SFML/SFML/commits/master[/url] :S

I made a thing [t]http://i.imgur.com/zvl1Qx4.gif[/t] It's not much, but it's still quite an accomplishment for me.

[QUOTE=SgtPsychic;49971821]I made a thing [t]http://i.imgur.com/zvl1Qx4.gif[/t] It's not much, but it's still quite an accomplishment for me.[/QUOTE] Dungeon Keeper fan sequel?

did an implementation of DBSCAN for some good ole automatic clustering synthetic data set produced with a mixture of matlab and paint.NET: [img]http://i.imgur.com/65EEViq.png[/img] converted to XY data, clustered with DBSCAN: [img]http://i.imgur.com/PI2NSmu.png[/img] bonus - DBSCAN applied to Old Faithful dataset: [img]http://i.imgur.com/lcVYyKN.png[/img]

I get a real kick out writing light related things in Unity so I decided to write some simple position light code that can get re-used for a basically anything with a light flare. It's nothing too complicated, but the results look nice. The whole thing works based on a custom quad based GameObject. The quad rotates to face the camera like any other sprite, but there’s an offset that you can now enter which allows it to pass in front of geometry as needed. This helps to prevent the ugly scenario where a quad is clipping through some really key geometry. The quad also shrinks in size based on a specified max angle so that for directional light situations, the light is difficult to see unless you’re looking down it. This is especially useful for spotlights. These lights can be set to blink with three parameters: Duration, ramp time, and delay. Duration is how long a light holds its max size at the blink, ramp time is how long it takes to get to that max value, and delay is how long between each successive blink. Using this allows you to create flashing strobe lights (not in the video) or slow fading pulsing lights (in the video). Lights can be set to automatically generate a physical light so that they can cast light. The light is automatically handled and reflects any blinking that the light might be doing. Finally, the lights scale with distance (up to a point) so that you can see them far away. The headlight in particular, due to its size, is extremely visible from far away. [media]https://youtu.be/8DrlSlPbkjo[/media]