I made a Minefield-clone and I'm pretty satisfied :)
Next up.. Pong with power-ups? I'll see. Oh, well, I'm already looking forward to making stuff in 3D!
Slightly more advanced triggers/events:
It's amazing how much this thread both entirely kills and boosts my work ethic at the same time
I'm yet again plagued by the curse of blurry text in Love
This really just pisses me off, because there's no way I can find to turn off this automatic text-rape
I wish I were better at programming. The only thing I've ever created was in June, and it was this
Needless to say, extremely simple, and yet it took me forever to figure out how to correctly utilize the while loop. At any rate, I can't look back on the code now because I lost it when my hard drive died.
Figured out the source of the blurring problem.
Fonts default to linear/linear filtering. There is no method for changing a font's filters. The only time that you can specify the filter is by optionally passing it in the constructor. The real reason this is a problem is that love.graphics.newFont doesn't ask if you want to use different filtering, and doesn't pass anything into instance->newFont so you're pretty much screwed
I have nothing to say...
My life is complete.
Got the technical interview with RiotGames tomorrow. I hope its not going to be a standard/boring/stupid technical interview. I really hate those interviews were they ask you to write some code and say it over the phone (looking at you amazon). I really hope I get to talk in depth about the technical aspect of LoLNotes.
write a binary search
I finally understand shadow mapping.
I can't believe it took me so long, though. Next up: filtering.
Second, you don't want a dark halo with SSAO, but that's often what you get. The screen-space approach is fundamentally, physically wrong, and the only reason it looks OK some of the time is because graphics programmers are masters of voodoo. SSAO is probably one of the most difficult things to make look reasonable. Just look at how many real games actually ship with bad SSAO. Amnesia comes to mind.
old pic http://i49.tinypic.com/3446rl2.png
Obvious problem: causes some sort of banding at a distance, in non-shadowed areas. Also, still has aliasing.
Problem you can't see: crashes my graphics card if you look at an area the shadow map doesn't cover. whoops.
EDIT: solved all my problems, except the aliasing. I guess that's next.
Maybe try ESMs? They're actually really simple to implement.
If he used R32F he would have more precision, resulting in less shadow bias needed to remove the acne that you can see it on the self shadowed parts.
In my path tracer, a pixel can end up, after sampling, having colors like (15000, 3200, 1050). Currently, I divide this value by the number of samples. The problem is, when this get's put into the final 32 value, each component get's clamped to a max of 255, and this can happen
That pink/purple color you see on the front of the sphere is the result of the extremely bright light behind the camera. What happens is the red component get's clamped to 255, while the green and blue were already below 255, so they stay the same, resulting in a different color.
So the question is: how do I prevent over-exposure? The naive approach would be to find the most intense color component in the entire image and then use that as your max. However, the problem is light sources; if something extremely bright is actually rendered on the screen, then everything else will become extremely dark.
I was contemplating doing something like calculating the standard deviation of the intensities in the image, and then using it to lop off the outliers, but I worry this might fail if a light source took up a large enough portion of the screen. I guess I could try to partition the data into populations, but I think at that point I'm out of my depth.
So, anyone have some experience in this area, or some clever solutions?
I am currently refining my python comic-bot for better usability, especially for adding new comics to it.
Every comic becomes it's own class, which independently fetches and posts comics from the website.
But the really useful thing is the automatic updater: It runs a shell-script which checks if there's a new version available on git. If that is true, it stops the python script, updates it via git, and executes it again.
No, really - given the state of most colleges these days, you're gonna come out of college with only a marginally better understanding of what that paragraph means.
If you really want to know what it means, start learning on your own. Look terms up on your own, try things on your own, experiment with things on your own, form your own hypotheses and conclusions.
Things you learn through personal experience will serve you infinitely better than anything you might ever pick up in college.
Let me start you off:
MSVC (Microsoft Visual C/C++) and GCC (GNU Compiler Collection) are, to put it simply, compilers. I'm sure you know this already, but compilers turn code a program.
An SDK is a Software Development Kit (used with compilers and code to help make more complex programs) and an API is an Application Programming Interface (various outside code that your code can interact with). SDKs typically consist of various APIs, tools, and more.
Marmalade is an SDK for making applications for mobile devices (iOS, Android, etc). Marmalade uses MSVC when it makes programs for you to test in the PC-based simulator, and it uses GCC when it makes programs for you to run on the mobile devices.
ARM is just the architecture (format of instructions) of programs for most mobile devices. GCC can build ARM instructions, so that's why Marmalade uses it when making a program for the mobile devices.
You're basing all of this off of second-hand knowledge from a particular college/area? And preaching others about it?
Your normals are still off. And I don't think it's because they're depth-derived. I'm not sure what method you're using for AO, either.
I'll take a few pictures from my renderer's implementation for reference. brb.