Thanks!   Not too much of a challenge in that Praxis LIVE was designed for connecting all these odd bits of technology together (mind you, writing that has been a challenge at times!   )


No, but it was well staffed when on site.  Also, I think it managed to appeal to those who might otherwise have wanted to cause trouble.


Possibly.  It's not something anyone specifically mentioned, and the age range of people having a go (2~72) might belie that.  Our interest is in creating things that are quite playful, intuitive and open-ended - there's no right or wrong way to play, which is different to the console games I've seen at least.


Not for long!  Lots of people said there's no way they'd be up for it, and most were lining up to have a go after 10 min.  


Currently the project has five different 'scenes', though it's something we intend to expand on.  Three of the scenes don't have interactive sound, only visuals, and use a variety of sample loops (mostly taken from old tracks of mine) and sequenced somewhat randomly / generatively.

There are two scenes with interactive sound.  The record scratching one tracks the horizontal position of the dancer and maps it to the speed and direction of the sample (actually position is mapped to acceleration in speed, which feels more natural).  The other scene, which I'm less happy with currently, is in the video between the logos at the end.  Each dancer has four 'strings' which trigger different guitar samples, and can pluck them from moving back and forth.

That answer your question?  This video shows some of the audio stuff in Praxis LIVE, but rather than binding a GUI to parameters, we're taking movement signals from the video pipelines.  NB. This is an oldish video now, some of the editing stuff has been improved recently.

<a href="http://www.youtube.com/v/khrOtNN7tN8?version=3&amp;hl=en_US&amp;start=" target="_blank">http://www.youtube.com/v/khrOtNN7tN8?version=3&amp;hl=en_US&amp;start=</a>

No they don't!     It's 1x-2x processing time and 1x-37x memory usage.  What did you say about compact earlier? 

Thought I'd share a few details of a recent project I've been involved in.  Whether you're entirely happy with this being classed as a "game" depends on whether you think all games need to have goals, high-score tables, or be playable on your PC - needless to say, I don't! 



About

At Digital Prisoners we're interested in creating interactive things for people to play with out in the real world.  Meeting Point is a large-scale interactive projection designed for an urban public space. It uses two infra-red cameras mounted at opposite sides of the space, custom computer software and a large-scale projector.  The work allows the two participants to interact with each other and, through motion detection, with the other audio and visual elements of each section.  For example, the record scratching section allows them to control the spin on screen and the sound of the record by moving from side to side.

<a href="http://www.youtube.com/v/lXLmhCwWSNw?version=3&amp;hl=en_US&amp;start=" target="_blank">http://www.youtube.com/v/lXLmhCwWSNw?version=3&amp;hl=en_US&amp;start=</a>

Technical Details

Most importantly, it's Java-based! 

• This project was built with Praxis LIVE (also in my sig). It is the sort of project Praxis LIVE was designed for.
• The main projection uses Praxis' OpenGL pipeline, which uses LWJGL and some (heavily forked) code from libGDX. This makes quite a lot of the custom (live) coding support for GLSL and Java.
• Video input uses two infra-red CCTV camera, USB capture devices (ran out of PCI slots!  ) and GStreamer bindings.  Each video stream is actually split into two using the V4L2loopback module ...
• One stream from each camera goes to the OpenGL pipeline.  A second stream from each camera goes into a software pipeline that does motion detection, which is used to pass parameters to control audio and visual elements in each scene.
• The audio processing is pure Java using Praxis LIVE's audio FX (most of the effects code is up at https://github.com/jaudiolibs/)
• The whole thing is projected using a 10,000 lumen Sanyo projector.

If you want to know anything else about the implementation, please ask below.



I wasn't sure the best place to post this.  Almost put it in Showcase, as it is a finished project and kind of qualifies as a game.  However, it doesn't entirely meet the criteria of "a casual visitor should be able to play your game without any trouble".  Of course, if you've got a large space and a spare £4k (projector hire ain't cheap!) we'd be happy to bring it to you for a few days. 

For a moment I thought you were just repeating what I wrote above  , but I see what you're trying to do.

Two questions (not tried it)
- why use getPath() rather than construct the File from the URI returned from toURI()?
- why not use getParentFile() to return a File representing the directory?

https://github.com/Harris6310/Dragonshire/blob/master/src/dragonshire/graphics/Texture.java#L58 ?

Your texture doesn't appear to have an alpha channel - shouldn't that be GL_RGBA?

At a guess, you haven't enabled blending?

Which isn't the same thing!

Mind you, as the OP says, he might be better off putting the level files in the JAR - depends if he wants it to be user editable / extendable.

You're trying to call split() on an array!  You need to use a second loop through the tempTwo array.

To assume makes an ass of u and me!  

Don't assume that the JAR is launched from the directory it is in.  That assumption will break in interesting ways.  If your program relies on the directory its JAR is in and not the directory the user is in, don't use user.dir - there's a clue in the name!  

You guys are misinterpreting what the user.dir property is meant to represent.  It is the current working directory, not the directory where the program resides.  For example, if you run a command in the shell (eg. ls) you want it to list the files in the working directory, not the directory where the ls command resides.  If anything's quirky it's probably Windows Java behaviour here.

One way to answer the OP's question may be to use .  Obviously SomeClass should be a class in the JAR you're looking for.

See more http://stackoverflow.com/questions/2837263/how-do-i-get-the-directory-that-the-currently-executing-jar-file-is-in

If you go with something like this, I'd highly recommend doing <Year><Month><Day>, and always using two digit numbers (or 4 for year if you're planning on your code being used into the next century  ).

ie. <GameName>-130509

That way it is always incrementing and sorts correctly 'alphabetically' - don't underestimate how useful those two features can be!

You try dragging with the right mouse button?  I thought it was broken too until I looked at the code.


Except that the vast majority of this is not Java2D, it's direct pixel manipulation, which is highly consistent across computers.  This would probably perform better if he switched to an active rendered buffer strategy for the final blitting.

Try searching!    http://www.java-gaming.org/topics/need-a-really-simple-library-for-playing-sounds-and-music-try-tinysound/25974/view.html

An obvious weirdness in your code would appear to be that the constructor is calling itself.

Never use a Thread per sound, or open multiple lines at the same time - it'll break or play badly on a variety of systems.  If you don't want to get into handling sound mixing yourself, check out TinySound or other libraries on here.

I missed out that you'll probably need the antialiasing hint too.  That still might not work with drawImage() though.  See this blog post from 2007 - http://weblogs.java.net/blog/campbell/archive/2007/03/java_2d_tricker.html.  Not sure if that's still accurate.  I've seen code in the Java2D implementation that seems to treat blitting sub-pixel positioned images differently.  As you said, unless this is on an accelerated pipeline, it's going to be slow.


Different meaning (well usage) of interpolation.

Yes and no.  Both Java2D and OpenGL can use interpolation to give the appearance of sub-pixel accuracy through interpolation.  As the Java2D drawImage calls only take ints, you have to use the form that takes an AffineTransform, and also make sure that interpolation is set to bilinear or bicubic.  Of course, you didn't want this to work quickly, right? 


Depending on your algorithm, using might be better - will have the effect of rounding.

Your argument would appear to be backwards! 

Use the builder pattern if lots of data is different with every instance (particularly if that data needs to be known at construction time - eg. immutable state)

Use Big constructors if little data has to be passed in at construction time (ie: lots of it is the same as default, there are few parameters, or you're happy with mutable state / setters)


evil? 

How about something based on the builder pattern instead?  This would lead to code like below, without lots of specific subclasses.  Makes this potentially easier to customize or switch to an XML / JSON approach later, while keeping your code the same.



I really like the way they're doing this in JavaFX to provide a clean Java DSL that also translates easily to XML.

PS. Yes, I think your code is evil! 

Yes, my laptop (which is getting old  ) has 4GB of RAM, which seems to be the low-end these days.  That's enough RAM (excluding swap) to store over 6 hours of stereo audio!  Storing a few minutes of audio at a time in RAM is hardly excessive.   

So does dyn.js - clue in the name!  Not tried it yet. Be interesting to see how it compares with Nashorn. At least you don't need JDK8.

Then you could just use it as example code to answer your question. Low level audio code is difficult to get right. Primary point is to never use more than one output line, keep it open and mix all your sounds in a single thread to the output line. Ignore Clip as it uses a line per sound.

Or there's Rhino (JDK 1.4+) or dyn.js (JDK 7+).  They all compile to bytecode.  That does not mean they'll perform equally well!  Compilation to bytecode is not in itself a guarantee of being "incredibly fast". 

Still not managed to get that to perform any better (or even as good as) -Xincgc for me.  Must test again sometime though.

The max pause setting may work with other garbage collectors too.

hmm .. tempting!

And while we're on a Mike Patton lovefest - 3 faves of mine.

<a href="http://www.youtube.com/v/XQ7p623CBvI?version=3&amp;hl=en_US&amp;start=" target="_blank">http://www.youtube.com/v/XQ7p623CBvI?version=3&amp;hl=en_US&amp;start=</a>

<a href="http://www.youtube.com/v/0OblDI7loLs?version=3&amp;hl=en_US&amp;start=" target="_blank">http://www.youtube.com/v/0OblDI7loLs?version=3&amp;hl=en_US&amp;start=</a>

<a href="http://www.youtube.com/v/75H4ol-NljM?version=3&amp;hl=en_US&amp;start=" target="_blank">http://www.youtube.com/v/75H4ol-NljM?version=3&amp;hl=en_US&amp;start=</a>

Mind you, don't think I could code to any of them! 

So, you basically want open-source without the most important benefit that open-source brings?  I thought your first comment was funny - this one's hilarious! 

For a start, how do you define "abandoned" anyway?  On who's say so?

Personally, I'm all for the GitHub approach - fork, fork and fork away.  I think it's highly important that distributors are allowed to fix bugs and add features, and usually they make their way back upstream.

Taking an example of OpenOffice / LibreOffice.  Even before the LibreOffice fork, most Linux distros shipped a modified build of OpenOffice that contained a range of additional features and bug fixes.  Should that not have been allowed?  Should the fork of LibreOffice not have been allowed, despite the fact that this has resulted in the project developing much more rapidly?

Personally, I'm glad you're not making the rules! 

Don't want to be a party pooper, but you don't know what you're talking about! 

There are bits of JavaSound that are really bad, but the direct audio mixers are OK, and about the most low-level way you can interact with the soundcard.  Open device, stream bytes - that's it!  To say that TinySound just wraps JavaSound is rubbish - it provides a range of higher-level functionality on top of the usable low-level bits of JavaSound. 

If you're going to suggest OpenAL as a "nice alternative", then to TinySound maybe, but not the JavaSound direct mixers - OpenAL is a higher level API - you could write a pure-Java equivalent outputting via the JavaSound direct mixers!

Dang!  You didn't buy that RAM for it to actually be used by anything did you?! 

Seriously, unused RAM is a sign of an unoptimized system.  Let the JVM and the OS manage the RAM for you - it will do a damn sight better job of it.

Take @matheus23's suggestion for command line options to control heap size if you really feel you must.  Just don't use System.gc() - as well as the arguments already put, a full GC is likely to play havoc with MIDI / audio timing too. 

You comparing like with like there?  ie. OpenJDK 7 with Oracle Java 7?  The default OpenJDK on Ubuntu is 6, but 7 is in the repos.  They shouldn't be that much different in speed - they're practically the same code base. 

Is Pinta any good?


I'm sorry, but WTF does that actually mean?

Well, I guess you'd better not be using libGDX or LWJGL, or Eclipse / NetBeans, or Java 7+.  And you'd better not be using a decent web browser to look at this site, or using this site at all. 


Works both ways!  My number one answer when people ask me what Linux offers that Windows doesn't - No longer having to pay for shit that doesn't work.  We get all our own shit that doesn't work, for FREE!