Libraries You Wish For

General Discussions
#1

I’ve seen a number of projects, libraries, and utilities pop up on this forum with varying degrees of adoption and acclaim. Other than texture atlas/sprite sheet loading and manipulation and princec’s interest in memory manipulation/mapped objects, I haven’t seen many specific recurring complains about non-existent libraries.
Are most of JGO’s family members happy with the tools and features available for Java game development?

Your problem could lie with the core Java libraries, or maybe OpenGL or lwjgl, or some pattern that you frequently encounter in your coding.
I’m sure some of you have at some point been annoyed at having to open a file reader with:

new BufferedReader(new InputStreamReader(new FileInputStream(file)));

or at having to type:

Map.Entry<Abc, Xyz> entry = new AbstractMap.SimpleImmutableEntry(a, x);

just to create an entry to store in some collection and wished for an Entry class in Java.

The example boiler plate code can easily be solved with a utility class. Is there a specific library or functionality that you wish existed in Java, but you can’t find anywhere online. Maybe it’s related to logging, or the Java collections framework, or OpenGL’s state based nature, or serialization?

Please post, discuss, share your problems/solutions :slight_smile:

#2

Sometimes I want random numbers and don’t care about the seed or anything, so I made a class that manages a static random instance and has a few helper functions (like [icode]random(min, max)[/icode])

Saves me a lot of time.

#3

I made a class a while ago (years actually, jeez doesn’t seem that long) that acted as a replacement for java.awt.Graphics, had all the simple drawing methods, but acted on an integer array instead of an image. Was quite useful for the falling sand game I wrote way back when.

Although @Heroes, isn’t that more or less Math.random()? A static random instance?

#4

An instance of [icode]java.util.Random[/icode], because it has more useful methods.

#5

I’ve made a complete custom binary serialization/deserialization protocol library. I had to do it because I needed something more robust than Java serialization - mine is proof against DoS attacks for example caused by a binary stream that, say, specifies huge 20mb arrays. It’s also slightly faster and more lightweight but those are not really relevant side effects.

I’ve also on top of that made a custom RMI client and server system to replace Java RMI, for similar reasons. It’s much simpler though it does handle a few clever things like serializing remote references. It’s based on the aforementioned serialization lib.

I’ve got a library of *List, *Grid and *Cube classes for primitives and objects which is invaluably useful and I might even think about implementing Roquen’s Morton functions in the lookups for fun.

Cas :slight_smile:

#6

If you are using Java 7+, you can use the NIO.2 API which is pretty simple:

Files.newBufferedReader(filePath, Charset.defaultCharset());

IMO, the Java community has pretty amazing libraries that cover all the basics.

#7

I think my most common time sink that I wish was simpler is saving and load basic properties. The Properties class definitely gets me most of the way there, but it’s still annoying to try and save for example a Color preference.
One or two lines of code to convert the color to an integer or hex string, then another two or three lines to read it back and convert it to an integer and then to a color. You end up with a lot of boiler plate code to support property types other than strings (file paths, floats, integers, colors, etc).

Princec, yes, I’ve been reading Effective Java and the last chapter of the book is about serialization and there are so many issues with just marking a class serializable: compatibility, injection attacks, security, etc. Serialization is definitely a poorly implemented language feature; to do it properly you need to add read and write methods and do all of the serialization processing yourself.

#8

Hell I always have a Util class that has methods like log(Str), log(Prefix, Str), random functions, float/int/bytebuffer functions and so on. Saves me a bunch of time.

#9

You ever try Preferences?


Preferences prefs = Preferences.userNodeForPackage(getClass());

String playerName = prefs.get("player_name", "Default Name");
int highScore = prefs.getInt("high_score", 0);
Color thatColor = new Color(prefs.getInt("special_color", 0xFFFFFFFF));
...
prefs.putInt("special_color", thatColor.getRGB());

Still can’t auto-serialize objects or anything, but I’d say it’s still more convenient than Properties.

#10

Got loads of static helper classes like this:


public static float fastAbs(final float f)
    {
        return f >= 0.0f ? f : -f;
    }

    public static double fastAbs(final double d)
    {
        return d >= 0.0D ? d : -d;
    }

    public static long fastAbs(final long d)
    {
        return d >= 0l ? d : -d;
    }

    public static float clamp(float value)
    {
        if (value > 1.0f)
            return 1.0f;
        if (value < 0.0f)
            return 0.0f;
        return value;
    }

    public static float clamp(float value, float min, float max)
    {
        if (value > max)
            return max;
        if (value < min)
            return min;
        return value;
    }

Also got some class with fast sin/cos functions and float pi consts


public static final float PIf=(float)Math.PI, PI2f=2*PIf, PI05f=0.5f*PIf, PI025f=0.25f*PIf, PI075f=0.75f*PIf, PI15f=1.5f*PIf;
#11

@Robin
If you are really going for the explicit purpose of “fast,” I wouldn’t use conditionals:
http://www.java-gaming.org/topics/bit-twiddle-amp-branch-removal/21443/view.html
However things might have changed in the JVM since 2009 enough to make these irrelevant.

Also Riven has some tricks on his blog: http://riven8192.blogspot.com/2009/08/fastmath-sincos-lookup-tables.html

A fast XOR shift RNG I like to use if I need tens of millions of integers a second:


/**
* Returns random int between 0 and n
* Includes 0, excludes n
*/
public static final int randInt(int n) {
        seed ^= (seed << 1);
        seed ^= (seed >>> 5);
        seed ^= (seed << 9);
        int result = seed % n;
        return result < 0 ? -result : result;
}
static int seed = 48659236;

Hmm, I should probably stop, this thread could very quickly turn into a mini version of the Shared Code board.

#12

Good to know.

Yes, this thread ended up being a little broad, I was specifically wondering what types of libraries people wanted, but could not find. Maybe most commonly needed library have already been developed, or maybe we don’t know what we’re missing until it gets developed. Anyway, the focus was to talk about what does not exist currently, not things that did not exist previously, but does now :slight_smile:

#13

Conditionals are always tricky. Does hotspot convert into a branch or not…if a branch on average will the prediction be correct. A correctly predicted branch is as close to free as possible…mispredicted can get quite expensive. Hotspot has change alot, but branchless versions are still interesting. As an example HotSpot engineers are currently wondering what to do about Math.max & Math.min…both of which are intrinsic, but they way they are lowering (to a conditional move) can have drastically negative impact on performance. (The start of the conversion is here: http://comments.gmane.org/gmane.comp.java.openjdk.hotspot.compiler.devel/13893, but there’s quite a few comments since) A specific comment in that thread, no showing here is “Bit twiddling vs cmov is hard to guess at. With register renaming (and register files seem to be growing) and more exec units it’s possible that bit twiddling can end up faster, but sure, this is not a rule.” For min/max is dep-chain length is four and it needs one temp register…not heavy weight, so it’s going to depend on what surround code is doing.

But in general, just use one that works. You only need to think about the choice at some “spots” that are inside something you need to juice cycles out of and you can’t think of any other options.

[icode]int result = seed % n; return result < 0 ? -result : result;[/icode]

can be replaced by

[icode]return (seed>>>1) % n;[/icode]

and you can kill the division by treating the result as fixed-point (https://github.com/roquendm/JGO-Grabbag/blob/master/src/roquen/math/rng/PRNG.java)

#14

Oh I skipped the middle ground: icode (n * ((result >>> 12) * 0x1p-52));[/icode]

There lots of libraries I people wish would write for or port to java. A recently mentioned is recast detour for navigation meshes.