Here are three blog posts I wrote on the University of Edinburgh Insect Robotics Group blog that describe in detail how I made RoboAnt.
It was a day like any other when my Honours Project supervisor told me he has a surprise for me. Continue reading
Recently I was struck by a few nice ideas about TheHunt and I’m in a hurry to write them down. Here we go:
- Knife tool. Been thinking for a while how to deal with fish hiding in a huge algae and now I think I figured it out – using the knife to cut the big into small ones. Should be easy to implement, I give it half a week.
- Contextual menu on long-click. Long press somewhere, you get a nice pop-up menu where you can change tools, maybe request info about the object picked and other undecided stuff. Navigate in it without releasing the press. Can be tricky, I give it a week.
- Simplified interface. Just one number in the top middle, showing score. Long press for a menu, maybe pop-ups with more information if needed. After contextual menu is implemented, only pop-ups will be missing.
- Nicer font. I will experiment, but I’m thinking of something that looks hand-drawn. Easy to implement, but may require some time to find a proper font. I give it a day.
A quick concept to show the simplified interface and the contextual menu (didn’t include the knife and the nicer font)
In a week or two I hope to have made a visible progress towards a more playable TheHunt!
I have just finished porting fractious’s Rendering Text in OpenGL on Android to OpenGL ES 2.0 (this is the mobile version of OpenGL 3.0 and the main difference with the older versions OpenGL is having acces to the shaders, which allow us to run code on the GPU).
I had to do this because my project TheHunt uses, you guessed it, the newer version. Reason is that it would allow me to do some nifty shader tricks… some day 🙂
Some implementation details:
- I firstly started by simply converting the OpenGL ES 1 commands to the newer version. The Model, View and Projection matrices were passed using a uniform variable to the shaders, i.e. all the letters used the same matrices. This was good enough to produce horizontal text
- In TheHunt I use text to label events (fishbone flops, net snatches), and I need this text to be tilted (it would be somewhat boring otherwise). For this I needed to be able to assign individual model matrices to each word. A bit tricky, but using Sprite Batching in OpenGL ES 2.0 | Anton Holmquist as inspiration I managed to do it. In short, instead of an uniform Model-View-Projection matrix, the vertex shader has an uniform array of matrices. I fill this array with an individual matrix for each letter and also pass a matrix index attribute for each vertex (the exact same method suggested by Anton Holmquist.) The result is that each GLText::draw call can tilt the string drawn with a certain angle (it can now receive an angle argument, in degrees).
- The last catch was drawing color text – at first, all text was coming out black for me. The reason turns out to be that the texture is defined as grayscale, so in the fragment shader we need to multiply the color we want for the text (passed as uniform u_Color) with the grayscale value (called W in OpenGL) of the texture (not with the whole texture color, because it is something like [0, 0, 0, grayscale] which was resulting in the all black text):
gl_FragColor = texture2D(u_Texture, v_TexCoordinate).w * u_Color
— from BatchTextProgram.java
That’s all I can think of, and the result is efficient text drawing in OpenGL ES 2.0, and more importantly in TheHunt, where you can expect a nice GUI to appear soon!
Today was a day of bug fixing. I’m keeping myself busy with two projects right now:
- TheHunt – Just made batch drawing of text work, so expect an update soon!
- Ruby on Rails project – a friend and I are trying to put a website together. Rails is great. Taking an XLSX file and reading it into the database – done!
That’s more than enough to sleep soundly. Good night! ^^
Firstly, I apologize for the rather big break – I will try to be more regular from now on…
But finally I feel like I have something noteworthy to say, and show:
On the website above you can:
- Download the current best version
- View the full source code
- Contribute! bug report, bug fix, adding a feature… or just a friendly comment on it, all are priceless =]
- Android game and live wallpaper simulating an artificial environment with algae and a fish (currently more like a fish bone, really)
- Fish tries to eat as much as it can, munching on algae and food you’ve placed
- You can catch the fish by surrounding it with a net
- Open sourced, idea is to end up with other agents using the environment, maybe even interacting with each other (a crab? a seal?…)
- Will be in the Play Store, eventually, when it matures enough
I will be using this blog to post regular updates on it, as well some behind the scenes information about how things work… also to answer to feedback you guys might have!
That’s it for now, I’ll be back soon to tell a bit more about some incoming features and maybe set some milestones!
This is a follow up post to SudokuH – Fast Sudoku Solver in Haskell.
Let’s see how SudokuH is made. I will try to be as little technical as possible, but it may still be a long read.
The first surprise! You open up the source code, and what do you see? Pure awesomeness. This has little to do with my pro skills (that’s short for programming skills, if you wonder), and more with Haskell. Let me tell you, I love Haskell. My feelings towards it deserve a separate post, so I will just say that Functional Programming is powerful and elegant. It does take some time to get used to but after this writing in imperative languages (like C, Java) feels… obsolete. If I had to implement the algorithms in SudokuSolver.hs in, say, Java, it might have very well become 500+ lines of code (compared to around 150 right now without the comments). So… if you don’t know Haskell, why not give it a try?