jetDrone

Vert.x and Juju

Thu, 14 Mar 2013 10:38:51 UTC

I've been playing with Juju and Vert.x and I got a simple DEVOPS juju charm to deploy a Vert.x app with the minimal effort. Here is the required script:

juju deploy --repository juju-charms local:vertx-app juju deploy redis-master

juju deploy haproxy

juju add-relation redis-master:db myapp

juju add-relation myapp haproxy

juju add-unit -n 10 myapp

juju expose haproxy

Use the status command to find the public IP address and enjoy! The app at the moment is hard coded to be a Hello World but work is in progress to make it configurable.

vert.x is awsome! Specially with BSON!

Mon, 14 Jan 2013 18:53:40 UTC

Vert.x is a polyglot event-driven application framework that runs on the Java Virtual Machine.

Similar environments written in other programming languages include Node.js for JavaScript that I've been working for the last 1 and a half year.

Vert.x exposes the API currently in Java, JavaScript, Groovy, Ruby and Python.

Scala and Clojure support is on the roadmap.

The application framework includes these features:

Polyglot. Application components can be written in Java, JavaScript, Groovy, Ruby or Python.
Simple concurrency model. All code is single threaded, freeing from the hassle of multi-threaded programming.
Simple, asynchronous programming model for writing truly scalable non-blocking applications.
Distributed event bus that spans the client and server side. The event bus even penetrates into in-browser JavaScript allowing to create effortless so-called real-time web applications.
Module system and public module repository, to re-use and share components.

I do like the freedom of being asynchronous and synchronous when needed, I like the real distributed programming model (not like the advertisement from Node.JS which in reallity is a process fork() with modules that require extra coding). With vert.x you just specify the number of instances and you're done!

I disliked the fact that all internal messages were JSON. The event bus is a wonderful component but JSON is too generic. It only allows String, Boolean, Double, Null, Lists and Hashes. Therefore I started a new vert.x module that uses BSON. I picked BSON because it maps easily to JSON and can be a simple replacement.

It turns out you will get a server 33% faster!!! if you use my module!!!

So get it now!!!

Android Clonabalt

Thu, 28 Jul 2011 19:59:29 UTC

It took a couple of days to make a basic clone of the popular game. I did not look to the original code, in fact i did not reuse any of it, and even wrote my own engine and sprites. The all game is just 50kb with resources for popular screen sizes, QVGA, HVGA and WVGA. The APK can be picked up from my dropbox.

This was a learning experience so it will not be published on any market. I might open source the minimal engine (basically 2 classes) but at the moment it is not a good idea since i haven't document anything.

SFX Audio on Android

Tue, 28 Jun 2011 11:24:07 UTC

Once upon the time all game audio was synthesized. We were amazed with the chips that would come out from the ZX Spectrum or the commodore 64 but nowadays we can still make cool explosion sounds for small devices such as the android mobile phones.

I will not diverge into much details on audio synthetising since I am not an expert myself. If you want information about that you can look here:

So i implemented a simple SFX util class based on an old project (but very useful: http://www.drpetter.se/project_sfxr.html) to generate sounds for Android games. The code is the following:

package com.jetdrone.and2d.sfx;
import java.util.Random;
import android.util.FloatMath;
public class SFXR {
  // 0: square, 1: sawtooth, 2: sine, 3: noise
  private int wave_type;
  private float p_base_freq; // Start Frequency
  private float p_freq_limit; // Min Frequency
  private float p_freq_ramp; // Slide
  private float p_freq_dramp; // Delta Slide
  private float p_duty; // Square Duty
  private float p_duty_ramp; // Duty Sweep
  private float p_vib_strength; // Vibrato Depth
  private float p_vib_speed; // Vibrato Speed
  private float p_vib_delay; // ???
  private float p_env_attack; // Attack Time
  private float p_env_sustain; // Sustain Time
  private float p_env_decay; // Decay Time
  private float p_env_punch; // Sustain Punch
  boolean filter_on; // ???
  private float p_lpf_resonance; // LP Filter Resonance
  private float p_lpf_freq; // LP Filter Cutoff
  private float p_lpf_ramp; // LP Filter Cutoff Sweep
  private float p_hpf_freq; // HP Filter Cutoff
  private float p_hpf_ramp; // HP Filter Cutoff Sweep
  private float p_pha_offset; // Phaser Offset
  private float p_pha_ramp; // Phaser Sweep
  private float p_repeat_speed; // Repeat Speed
  private float p_arp_speed; // Change Speed
  private float p_arp_mod; // Change Amount
  private float master_vol = 0.05f;
  private float sound_vol = 0.5f;
  private boolean playing_sample = false;
  private int phase;
  private float fperiod;
  private float fmaxperiod;
  private float fslide;
  private float fdslide;
  private int period;
  private float square_duty;
  private float square_slide;
  private int env_stage;
  private int env_time;
  private int[] env_length = new int[3];
  private float env_vol;
  private float fphase;
  private float fdphase;
  private int iphase;
  private float[] phaser_buffer = new float[1024];
  private int ipp;
  private float[] noise_buffer = new float[32];
  private float fltp;
  private float fltdp;
  private float fltw;
  private float fltw_d;
  private float fltdmp;
  private float fltphp;
  private float flthp;
  private float flthp_d;
  private float vib_phase;
  private float vib_speed;
  private float vib_amp;
  private int rep_time;
  private int rep_limit;
  private int arp_time;
  private int arp_limit;
  private float arp_mod;
  private final Random rnd = new Random();
  public void init(long seed) {
    rnd.setSeed(seed);
    resetParams();
    playing_sample = true;
  }
  public void init() {
    resetParams();
    playing_sample = true;
  }
  
  private final float frnd(float v) {
    return rnd.nextFloat() * v;
  }
  
  private static final float fpow(float a, float b) {
    return (float) Math.pow(a, b);
  }
  
  private static final float fsin(float a) {
    return FloatMath.sin(a);
  }
  private final int rnd(int v) {
    return rnd.nextInt(v+1);
  }
  public void resetParams() {
    wave_type = 0;
    p_base_freq = 0.3f;
    p_freq_limit = 0.0f;
    p_freq_ramp = 0.0f;
    p_freq_dramp = 0.0f;
    p_duty = 0.0f;
    p_duty_ramp = 0.0f;
    p_vib_strength = 0.0f;
    p_vib_speed = 0.0f;
    p_vib_delay = 0.0f;
    p_env_attack = 0.0f;
    p_env_sustain = 0.3f;
    p_env_decay = 0.4f;
    p_env_punch = 0.0f;
    filter_on = false;
    p_lpf_resonance = 0.0f;
    p_lpf_freq = 1.0f;
    p_lpf_ramp = 0.0f;
    p_hpf_freq = 0.0f;
    p_hpf_ramp = 0.0f;
    p_pha_offset = 0.0f;
    p_pha_ramp = 0.0f;
    p_repeat_speed = 0.0f;
    p_arp_speed = 0.0f;
    p_arp_mod = 0.0f;
  }
  public void resetSample(boolean restart) {
    if (!restart)
      phase = 0;
    fperiod = 100.0f / (p_base_freq * p_base_freq + 0.001f);
    period = (int) fperiod;
    fmaxperiod = 100.0f / (p_freq_limit * p_freq_limit + 0.001f);
    fslide = 1.0f - fpow(p_freq_ramp, 3.0f) * 0.01f;
    fdslide = -fpow(p_freq_dramp, 3.0f) * 0.000001f;
    square_duty = 0.5f - p_duty * 0.5f;
    square_slide = -p_duty_ramp * 0.00005f;
    if (p_arp_mod >= 0.0f)
      arp_mod = 1.0f - fpow(p_arp_mod, 2.0f) * 0.9f;
    else
      arp_mod = 1.0f + fpow(p_arp_mod, 2.0f) * 10.0f;
    arp_time = 0;
    arp_limit = (int) (fpow(1.0f - p_arp_speed, 2.0f) * 20000 + 32);
    if (p_arp_speed == 1.0f)
      arp_limit = 0;
    if (!restart) {
      // reset filter
      fltp = 0.0f;
      fltdp = 0.0f;
      fltw = fpow(p_lpf_freq, 3.0f) * 0.1f;
      fltw_d = 1.0f + p_lpf_ramp * 0.0001f;
      fltdmp = 5.0f / (1.0f + fpow(p_lpf_resonance, 2.0f) * 20.0f)
          * (0.01f + fltw);
      if (fltdmp > 0.8f)
        fltdmp = 0.8f;
      fltphp = 0.0f;
      flthp = fpow(p_hpf_freq, 2.0f) * 0.1f;
      flthp_d = 1.0f + p_hpf_ramp * 0.0003f;
      // reset vibrato
      vib_phase = 0.0f;
      vib_speed = fpow(p_vib_speed, 2.0f) * 0.01f;
      vib_amp = p_vib_strength * 0.5f;
      // reset envelope
      env_vol = 0.0f;
      env_stage = 0;
      env_time = 0;
      env_length[0] = (int) (p_env_attack * p_env_attack * 100000.0f);
      env_length[1] = (int) (p_env_sustain * p_env_sustain * 100000.0f);
      env_length[2] = (int) (p_env_decay * p_env_decay * 100000.0f);
      fphase = fpow(p_pha_offset, 2.0f) * 1020.0f;
      if (p_pha_offset < 0.0f)
        fphase = -fphase;
      fdphase = fpow(p_pha_ramp, 2.0f) * 1.0f;
      if (p_pha_ramp < 0.0f)
        fdphase = -fdphase;
      iphase = Math.abs((int) fphase);
      ipp = 0;
      for (int i = 0; i < 1024; i++)
        phaser_buffer[i] = 0.0f;
      for (int i = 0; i < 32; i++)
        noise_buffer[i] = frnd(2.0f) - 1.0f;
      rep_time = 0;
      rep_limit = (int) (fpow(1.0f - p_repeat_speed, 2.0f) * 20000 + 32);
      if (p_repeat_speed == 0.0f)
        rep_limit = 0;
    }
  }
  public float synthSample() {
    if (!playing_sample)
      return 0.0f;
    rep_time++;
    if (rep_limit != 0 && rep_time >= rep_limit) {
      rep_time = 0;
      resetSample(true);
    }
    // frequency envelopes/arpeggios
    arp_time++;
    if (arp_limit != 0 && arp_time >= arp_limit) {
      arp_limit = 0;
      fperiod *= arp_mod;
    }
    fslide += fdslide;
    fperiod *= fslide;
    if (fperiod > fmaxperiod) {
      fperiod = fmaxperiod;
      if (p_freq_limit > 0.0f)
        playing_sample = false;
    }
    float rfperiod = fperiod;
    if (vib_amp > 0.0f) {
      vib_phase += vib_speed;
      rfperiod = fperiod * (1.0f + fsin(vib_phase) * vib_amp);
    }
    period = (int) rfperiod;
    if (period < 8)
      period = 8;
    square_duty += square_slide;
    if (square_duty < 0.0f)
      square_duty = 0.0f;
    if (square_duty > 0.5f)
      square_duty = 0.5f;
    // volume envelope
    env_time++;
    if (env_time > env_length[env_stage]) {
      env_time = 0;
      env_stage++;
      if (env_stage == 3)
        playing_sample = false;
    }
    if (env_stage == 0) {
      env_vol = (float) env_time / env_length[0];
    }
    if (env_stage == 1) {
      env_vol = 1.0f
          + fpow(1.0f - (float) env_time / env_length[1], 1.0f)
          * 2.0f * p_env_punch;
    }
    if (env_stage == 2) {
      env_vol = 1.0f - (float) env_time / env_length[2];
    }
    // phaser step
    fphase += fdphase;
    iphase = Math.abs((int) fphase);
    if (iphase > 1023)
      iphase = 1023;
    if (flthp_d != 0.0f) {
      flthp *= flthp_d;
      if (flthp < 0.00001f)
        flthp = 0.00001f;
      if (flthp > 0.1f)
        flthp = 0.1f;
    }
    float ssample = 0.0f;
    for (int si = 0; si < 8; si++) // 8x supersampling
    {
      float sample = 0.0f;
      phase++;
      if (phase >= period) {
        // phase=0;
        phase %= period;
        if (wave_type == 3) {
          for (int j = 0; j < 32; j++) {
            noise_buffer[j] = frnd(2.0f) - 1.0f;
          }
        }
      }
      // base waveform
      float fp = (float) phase / period;
      switch (wave_type) {
      case 0: // square
        if (fp < square_duty)
          sample = 0.5f;
        else
          sample = -0.5f;
        break;
      case 1: // sawtooth
        sample = 1.0f - fp * 2;
        break;
      case 2: // sine
        sample = fsin(fp * 2 * (float) Math.PI);
        break;
      case 3: // noise
        sample = noise_buffer[phase * 32 / period];
        break;
      }
      // lp filter
      float pp = fltp;
      fltw *= fltw_d;
      if (fltw < 0.0f)
        fltw = 0.0f;
      if (fltw > 0.1f)
        fltw = 0.1f;
      if (p_lpf_freq != 1.0f) {
        fltdp += (sample - fltp) * fltw;
        fltdp -= fltdp * fltdmp;
      } else {
        fltp = sample;
        fltdp = 0.0f;
      }
      fltp += fltdp;
      // hp filter
      fltphp += fltp - pp;
      fltphp -= fltphp * flthp;
      sample = fltphp;
      // phaser
      phaser_buffer[ipp & 1023] = sample;
      sample += phaser_buffer[(ipp - iphase + 1024) & 1023];
      ipp = (ipp + 1) & 1023;
      // final accumulation and envelope application
      ssample += sample * env_vol;
    }
    ssample = ssample / 8 * master_vol;
    ssample *= 2.0f * sound_vol;
    if (ssample > 1.0f)
      ssample = 1.0f;
    if (ssample < -1.0f)
      ssample = -1.0f;
    return ssample;
    // }
  }
  public void random(int i) {
    switch (i) {
    case 0: // pickup/coin
      resetParams();
      p_base_freq = 0.4f + frnd(0.5f);
      p_env_attack = 0.0f;
      p_env_sustain = frnd(0.1f);
      p_env_decay = 0.1f + frnd(0.4f);
      p_env_punch = 0.3f + frnd(0.3f);
      if (rnd(1) > 0) {
        p_arp_speed = 0.5f + frnd(0.2f);
        p_arp_mod = 0.2f + frnd(0.4f);
      }
      break;
    case 1: // laser/shoot
      resetParams();
      wave_type = rnd(2);
      if (wave_type == 2 && rnd(1) > 0)
        wave_type = rnd(1);
      p_base_freq = 0.5f + frnd(0.5f);
      p_freq_limit = p_base_freq - 0.2f - frnd(0.6f);
      if (p_freq_limit < 0.2f)
        p_freq_limit = 0.2f;
      p_freq_ramp = -0.15f - frnd(0.2f);
      if (rnd(2) == 0) {
        p_base_freq = 0.3f + frnd(0.6f);
        p_freq_limit = frnd(0.1f);
        p_freq_ramp = -0.35f - frnd(0.3f);
      }
      if (rnd(1) > 0) {
        p_duty = frnd(0.5f);
        p_duty_ramp = frnd(0.2f);
      } else {
        p_duty = 0.4f + frnd(0.5f);
        p_duty_ramp = -frnd(0.7f);
      }
      p_env_attack = 0.0f;
      p_env_sustain = 0.1f + frnd(0.2f);
      p_env_decay = frnd(0.4f);
      if (rnd(1) > 0)
        p_env_punch = frnd(0.3f);
      if (rnd(2) == 0) {
        p_pha_offset = frnd(0.2f);
        p_pha_ramp = -frnd(0.2f);
      }
      if (rnd(1) > 0)
        p_hpf_freq = frnd(0.3f);
      break;
    case 2: // explosion
      resetParams();
      wave_type = 3;
      if (rnd(1) > 0) {
        p_base_freq = 0.1f + frnd(0.4f);
        p_freq_ramp = -0.1f + frnd(0.4f);
      } else {
        p_base_freq = 0.2f + frnd(0.7f);
        p_freq_ramp = -0.2f - frnd(0.2f);
      }
      p_base_freq *= p_base_freq;
      if (rnd(4) == 0)
        p_freq_ramp = 0.0f;
      if (rnd(2) == 0)
        p_repeat_speed = 0.3f + frnd(0.5f);
      p_env_attack = 0.0f;
      p_env_sustain = 0.1f + frnd(0.3f);
      p_env_decay = frnd(0.5f);
      if (rnd(1) == 0) {
        p_pha_offset = -0.3f + frnd(0.9f);
        p_pha_ramp = -frnd(0.3f);
      }
      p_env_punch = 0.2f + frnd(0.6f);
      if (rnd(1) > 0) {
        p_vib_strength = frnd(0.7f);
        p_vib_speed = frnd(0.6f);
      }
      if (rnd(2) == 0) {
        p_arp_speed = 0.6f + frnd(0.3f);
        p_arp_mod = 0.8f - frnd(1.6f);
      }
      break;
    case 3: // powerup
      resetParams();
      if (rnd(1) > 0)
        wave_type = 1;
      else
        p_duty = frnd(0.6f);
      if (rnd(1) > 0) {
        p_base_freq = 0.2f + frnd(0.3f);
        p_freq_ramp = 0.1f + frnd(0.4f);
        p_repeat_speed = 0.4f + frnd(0.4f);
      } else {
        p_base_freq = 0.2f + frnd(0.3f);
        p_freq_ramp = 0.05f + frnd(0.2f);
        if (rnd(1) > 0) {
          p_vib_strength = frnd(0.7f);
          p_vib_speed = frnd(0.6f);
        }
      }
      p_env_attack = 0.0f;
      p_env_sustain = frnd(0.4f);
      p_env_decay = 0.1f + frnd(0.4f);
      break;
    case 4: // hit/hurt
      resetParams();
      wave_type = rnd(2);
      if (wave_type == 2)
        wave_type = 3;
      if (wave_type == 0)
        p_duty = frnd(0.6f);
      p_base_freq = 0.2f + frnd(0.6f);
      p_freq_ramp = -0.3f - frnd(0.4f);
      p_env_attack = 0.0f;
      p_env_sustain = frnd(0.1f);
      p_env_decay = 0.1f + frnd(0.2f);
      if (rnd(1) > 0)
        p_hpf_freq = frnd(0.3f);
      break;
    case 5: // jump
      resetParams();
      wave_type = 0;
      p_duty = frnd(0.6f);
      p_base_freq = 0.3f + frnd(0.3f);
      p_freq_ramp = 0.1f + frnd(0.2f);
      p_env_attack = 0.0f;
      p_env_sustain = 0.1f + frnd(0.3f);
      p_env_decay = 0.1f + frnd(0.2f);
      if (rnd(1) > 0)
        p_hpf_freq = frnd(0.3f);
      if (rnd(1) > 0)
        p_lpf_freq = 1.0f - frnd(0.6f);
      break;
    case 6: // blip/select
      resetParams();
      wave_type = rnd(1);
      if (wave_type == 0)
        p_duty = frnd(0.6f);
      p_base_freq = 0.2f + frnd(0.4f);
      p_env_attack = 0.0f;
      p_env_sustain = 0.1f + frnd(0.1f);
      p_env_decay = frnd(0.2f);
      p_hpf_freq = 0.1f;
      break;
    default:
      break;
    }
  }
  public void randomize() {
    p_base_freq = fpow(frnd(2.0f) - 1.0f, 2.0f);
    if (rnd(1) > 0)
      p_base_freq = fpow(frnd(2.0f) - 1.0f, 3.0f) + 0.5f;
    p_freq_limit = 0.0f;
    p_freq_ramp = fpow(frnd(2.0f) - 1.0f, 5.0f);
    if (p_base_freq > 0.7f && p_freq_ramp > 0.2f)
      p_freq_ramp = -p_freq_ramp;
    if (p_base_freq < 0.2f && p_freq_ramp < -0.05f)
      p_freq_ramp = -p_freq_ramp;
    p_freq_dramp = fpow(frnd(2.0f) - 1.0f, 3.0f);
    p_duty = frnd(2.0f) - 1.0f;
    p_duty_ramp = fpow(frnd(2.0f) - 1.0f, 3.0f);
    p_vib_strength = fpow(frnd(2.0f) - 1.0f, 3.0f);
    p_vib_speed = frnd(2.0f) - 1.0f;
    p_vib_delay = frnd(2.0f) - 1.0f;
    p_env_attack = fpow(frnd(2.0f) - 1.0f, 3.0f);
    p_env_sustain = fpow(frnd(2.0f) - 1.0f, 2.0f);
    p_env_decay = frnd(2.0f) - 1.0f;
    p_env_punch = fpow(frnd(0.8f), 2.0f);
    if (p_env_attack + p_env_sustain + p_env_decay < 0.2f) {
      p_env_sustain += 0.2f + frnd(0.3f);
      p_env_decay += 0.2f + frnd(0.3f);
    }
    p_lpf_resonance = frnd(2.0f) - 1.0f;
    p_lpf_freq = 1.0f - fpow(frnd(1.0f), 3.0f);
    p_lpf_ramp = fpow(frnd(2.0f) - 1.0f, 3.0f);
    if (p_lpf_freq < 0.1f && p_lpf_ramp < -0.05f)
      p_lpf_ramp = -p_lpf_ramp;
    p_hpf_freq = fpow(frnd(1.0f), 5.0f);
    p_hpf_ramp = fpow(frnd(2.0f) - 1.0f, 5.0f);
    p_pha_offset = fpow(frnd(2.0f) - 1.0f, 3.0f);
    p_pha_ramp = fpow(frnd(2.0f) - 1.0f, 3.0f);
    p_repeat_speed = frnd(2.0f) - 1.0f;
    p_arp_speed = frnd(2.0f) - 1.0f;
    p_arp_mod = frnd(2.0f) - 1.0f;
  }
  public void mutate() {

    if (rnd(1) > 0)
      p_base_freq += frnd(0.1f) - 0.05f;
    if (rnd(1) > 0)
      p_freq_ramp += frnd(0.1f) - 0.05f;
    if (rnd(1) > 0)
      p_freq_dramp += frnd(0.1f) - 0.05f;
    if (rnd(1) > 0)
      p_duty += frnd(0.1f) - 0.05f;
    if (rnd(1) > 0)
      p_duty_ramp += frnd(0.1f) - 0.05f;
    if (rnd(1) > 0)
      p_vib_strength += frnd(0.1f) - 0.05f;
    if (rnd(1) > 0)
      p_vib_speed += frnd(0.1f) - 0.05f;
    if (rnd(1) > 0)
      p_vib_delay += frnd(0.1f) - 0.05f;
    if (rnd(1) > 0)
      p_env_attack += frnd(0.1f) - 0.05f;
    if (rnd(1) > 0)
      p_env_sustain += frnd(0.1f) - 0.05f;
    if (rnd(1) > 0)
      p_env_decay += frnd(0.1f) - 0.05f;
    if (rnd(1) > 0)
      p_env_punch += frnd(0.1f) - 0.05f;
    if (rnd(1) > 0)
      p_lpf_resonance += frnd(0.1f) - 0.05f;
    if (rnd(1) > 0)
      p_lpf_freq += frnd(0.1f) - 0.05f;
    if (rnd(1) > 0)
      p_lpf_ramp += frnd(0.1f) - 0.05f;
    if (rnd(1) > 0)
      p_hpf_freq += frnd(0.1f) - 0.05f;
    if (rnd(1) > 0)
      p_hpf_ramp += frnd(0.1f) - 0.05f;
    if (rnd(1) > 0)
      p_pha_offset += frnd(0.1f) - 0.05f;
    if (rnd(1) > 0)
      p_pha_ramp += frnd(0.1f) - 0.05f;
    if (rnd(1) > 0)
      p_repeat_speed += frnd(0.1f) - 0.05f;
    if (rnd(1) > 0)
      p_arp_speed += frnd(0.1f) - 0.05f;
    if (rnd(1) > 0)
      p_arp_mod += frnd(0.1f) - 0.05f;
  }
}

This class lets you generate sounds, but this is not enough since you also wants to listen to them. For this i created another helper class (AudioClip) that will let you play the sound on your Android device:

package com.jetdrone.and2d;
import android.media.AudioFormat;
import android.media.AudioManager;
import android.media.AudioTrack;
public class AudioClip {
  
  private AudioTrack track;
  private int sampleRateInHz = 22050;
  private short[] audioData;
  
  public AudioClip(int sampleRateInHz) {
    this.sampleRateInHz = sampleRateInHz;
  }
  
  public AudioClip(int sampleRateInHz, short[] audioData) {
    this.sampleRateInHz = sampleRateInHz;
    setData(audioData);
  }
  
  public void setData(short[] audioData) {
    
    if(track != null) {
      track.release();
    }
    
    final int bufSize = Math.max(sampleRateInHz, audioData.length);
    this.audioData = new short[bufSize];
    
    track = new AudioTrack(AudioManager.STREAM_MUSIC, sampleRateInHz, AudioFormat.CHANNEL_CONFIGURATION_MONO, AudioFormat.ENCODING_PCM_16BIT, bufSize, AudioTrack.MODE_STATIC);
    
    if(track.getState() == AudioTrack.STATE_NO_STATIC_DATA) {
      System.arraycopy(audioData, 0, this.audioData, 0, audioData.length);
      track.write(audioData, 0, audioData.length);
    }
  }
  
  public void play() {
    if(track != null) {
      track.play();
      track.stop();
      track.reloadStaticData();
    }
  }
  
  public void release() {
    if(track != null) {
      track.release();
    }
  }
  
  @Override
  public void finalize() throws Throwable {
    release();
    super.finalize();
  }
}

Now you can generate your sound in background and play the in the foreground, pretty neat! :)

PLAYPOWER

Wed, 18 May 2011 12:29:34 UTC

Learning Games for Radically Affordable Computers

X-Muppets!

Wed, 18 May 2011 12:24:32 UTC

[[photo:http://www.jetdrone.com/media/1/5]]

Quick fixes for annoyances on my Ubuntu 11.04

Wed, 18 May 2011 12:20:49 UTC

Unity slow with ATI drivers?

sudo apt-get install compizconfig-settings-manager

Then Disable VSYNC on OpenGL tab.

Eclipse acts wierd with new scrollbars?

sudo nano /usr/share/applications/eclipse.desktop

change the Exec with:

sh -c "LIBOVERLAY_SCROLLBAR=0 eclipse"

Need several instances of one app?

middle click on the launcher

WebGL does not work on chromium because your ATI card is blacklisted?

sudo nano /usr/share/applications/chromium-browser.desktop

change Exec with:

Exec=/usr/bin/chromium-browser --ignore-gpu-blacklist %U

MinPSP 11.2 HotFix (only Win32)

Fri, 13 May 2011 14:41:30 UTC

If you are on windows and faced a issue with missing DLLs, you can grab then here: minpsp-11.2-hotfix.zip You need to unpack the 2 DLLs on C:\pspsdk\libexec\gcc\psp\4.3.5 Change C:\pspsdk to whatever you choose to install the SDK to. By default it should be Ok. A proper fix with a new build has been added. This fixes both broken GCC due to missing DLL and as well PSPSH.exe Get it here: pspsdk-setup-0.11.2r2.exe

MinPSP 11.2

Fri, 13 May 2011 07:38:27 UTC

This is the second build of 2011, in this build there are only a few changes, i changed the build of oslib to build with its internal libs (do not rely on the SDK ones), DEB files for Debian/Ubuntu have been reduced from 150Mb to 32Mb (Changed from the standard compression to LZMA). On linux there is no mpfr/gmp dependency it caused problems with different versions of Ubuntu.

From the community i added a couple of patches, one that adds a pack to the SceModule struct and sync with the gentoo scripts for build fixes and better support on other environments.

Enjoy and happy coding :) get it here!

ActionScript to Java

Fri, 06 May 2011 13:25:26 UTC

One of these days I wanted to convert some AS2/3 to Java. It was obvious that it was simple since ActionScript and Java share lots of language constructs, however it is a tedious task so i created a simple helper application:

package com.jetdrone.as2j;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class AS2J {
  private static final Map AS2JTYPES = new HashMap();
  public static void main(String[] args) throws Exception {
    // e.g.: "~/Flixel2/as/AdamAtomic-flixel-348b55f"
    File asSourceDir = new File(args[0]);
    String skip = "docs";
    // e.g.: "~/src"
    File outSourceDir = new File(args[1]);
    AS2JTYPES.put("uint", "int");
    AS2JTYPES.put("Boolean", "boolean");
    AS2JTYPES.put("Number", "float");
    AS2JTYPES.put("Array", "java.util.List");
     processFile(asSourceDir, asSourceDir.getAbsolutePath(), outSourceDir, skip);
  }
  private static String getType(String type) {
    String t = AS2JTYPES.get(type.trim());
    if(t != null) {
      return t;
    }
    return type;
  }
  private static void processFile(File src, String prefix, File target, String skip)
      throws Exception {
    for(File f : src.listFiles()) {
      if(!f.getName().equals(skip)) {
        if(f.isDirectory()) {
          processFile(f, prefix, target, skip);
        } else {
          if(f.getName().endsWith(".as")) {
            String fname = f.getAbsolutePath();
            String sourceFileName = fname.substring(prefix.length(), fname.length() - 3) + ".java";
            convertFile(f, new File(target, sourceFileName));
          }
        }
      }
    }
  }
  private static void convertFile(File src, File dest) throws Exception {
    String l;
    BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream(src)));
    PrintWriter out = new PrintWriter(dest);
    int i=1;
    while((l = in.readLine()) != null) {
      try {
        l = processPackage(l);
        l = processConst(l);
        l = processVariable(l);
        l = processMethod(l);
        l = processConstructor(l);
        l = processGetter(l);
        l = processSetter(l);
        l = processCast(l);
      } catch(RuntimeException e) {
        System.err.println("ERR (" + i + "): [" + src.getAbsolutePath() + "]");
        System.err.println("  --> " + l);
      }
      out.println(l);
      i++;
    }
    in.close();
    out.close();
  }
  private static final Pattern PACKAGE = Pattern.compile("^\\s*package\\s+(.+)");
  private static String processPackage(String line) {
    Matcher matcher = PACKAGE.matcher(line);
    if (matcher.find()) {
      return line.substring(0, matcher.start()) + "package " + matcher.group(1) +
          ";" + line.substring(matcher.end());
    }
    return line;
  }
  // public var exists:Boolean;
    private static final Pattern VARIABLE = Pattern.compile("var\\s+(\\w+?)\\s*:\\s*(.+?);");
  private static String processVariable(String line) {
    Matcher matcher = VARIABLE.matcher(line);
    if (matcher.find()) {
      if(matcher.group(2).indexOf('=') != -1) {
        String type = matcher.group(2).substring(0, matcher.group(2).indexOf('='));
        String defaultValue = matcher.group(2).substring(matcher.group(2).indexOf('='));
        return line.substring(0, matcher.start()) + getType(type) + " " + matcher.group(1) +
            " " + defaultValue + ";" + line.substring(matcher.end());
        } else {
        return line.substring(0, matcher.start()) + getType(matcher.group(2)) + " " +
            matcher.group(1) + ";" + line.substring(matcher.end());
      }
    }
    return line;
  }
  // static public const A_LIST:uint = 0;
  private static final Pattern CONST = Pattern.compile("const\\s+(\\w+?)\\s*:\\s*(\\w+?)\\s*=\\s*(.+);");
  private static String processConst(String line) {
    Matcher matcher = CONST.matcher(line);
    if (matcher.find()) {
    return line.substring(0, matcher.start()) + "final " + getType(matcher.group(2)) +
        " " + matcher.group(1) + " = " + matcher.group(3) + ";" + line.substring(matcher.end());
    }
    return line;
  }
  // public function destroy():void
  private static final Pattern METHOD = Pattern.compile("function\\s+(\\w+?)\\s*\\((.*?)\\)\\s*:(\\w+)");
  private static String processMethod(String line) {
    Matcher matcher = METHOD.matcher(line);
    if (matcher.find()) {
      return line.substring(0, matcher.start()) + getType(matcher.group(3)) + " " +
          matcher.group(1) + "(" + processArgs(matcher.group(2)) + ")" + line.substring(matcher.end());
    }
    return line;
  }
  // public function destroy()
  private static final Pattern CONSTRUCTOR = Pattern.compile("function\\s+(\\w+?)\\s*\\((.*?)\\)");
  private static String processConstructor(String line) {
    Matcher matcher = CONSTRUCTOR.matcher(line);
    if (matcher.find()) {
      return line.substring(0, matcher.start()) + matcher.group(1) + "(" +
          processArgs(matcher.group(2)) + ")" + line.substring(matcher.end());
    }
    return line;
  }
  private static final String processArgs(String line) {
    StringBuffer sb = new StringBuffer();
    for(String p : line.split(",")) {
      sb.append(processArg(p));
      sb.append(", ");
    }
    if(sb.length() > 0) {
      sb.setLength(sb.length() - 2);
    }
    return sb.toString();
  }
  // Fixed:Boolean
  private static final Pattern PARAM = Pattern.compile("\\s*(\\w+?)\\s*:\\s*(.+)");
  private static final String processArg(String line) {
    Matcher matcher = PARAM.matcher(line);
    if (matcher.find()) {
      if(matcher.group(2).indexOf('=') != -1) {
        // java has no default values
        String defaultValue = matcher.group(2).substring(matcher.group(2).indexOf('=') + 1);
        return getType(matcher.group(2).substring(0, matcher.group(2).indexOf('='))) +
            " " + matcher.group(1) + " /*" + defaultValue + "*/";
      }
      return getType(matcher.group(2)) + " " + matcher.group(1);
    }
    return line;
  }
  // public get right():Number
  private static final Pattern GETTER = Pattern.compile(
      "function\\s+get\\s+(\\w+?)\\s*\\(.*\\)\\s*:\\s*(\\w+)");
  private static String processGetter(String line) {
    Matcher matcher = GETTER.matcher(line);
    if (matcher.find()) {
      String methodName = matcher.group(1);
      return line.substring(0, matcher.start()) + getType(matcher.group(2)) +
          " get" + methodName.substring(0, 1).toUpperCase() + methodName.substring(1) +
          "()" + line.substring(matcher.end());
    }
    return line;
  }
  // public get right():Number
  private static final Pattern SETTER = Pattern.compile(
      "function\\s+set\\s+(\\w+?)\\s*\\((.*)\\)\\s*:\\s*(\\w+)");
  private static String processSetter(String line) {
    Matcher matcher = SETTER.matcher(line);
    if (matcher.find()) {
      String methodName = matcher.group(1);
      return line.substring(0, matcher.start()) + getType(matcher.group(3)) +
          " set" + methodName.substring(0, 1).toUpperCase() + methodName.substring(1) +
          "(" + processArgs(matcher.group(2)) + ")" + line.substring(matcher.end());
    }
    return line;
  }
 
  // var members:Array = (Object as FlxGroup).members;
  private static final Pattern CAST = Pattern.compile("\\s*(\\S+?)\\s+as\\s+(\\w+)");
  private static String processCast(String line) {
    Matcher matcher = CAST.matcher(line);
    if (matcher.find()) {
      if(matcher.group(1).indexOf('=') != -1) {
        String prefix = matcher.group(1).substring(0, matcher.group(1).indexOf('=') + 1);
        String value = matcher.group(1).substring(matcher.group(1).indexOf('=') + 1);
        return line.substring(0, matcher.start()) + prefix + " (" +
            getType(matcher.group(2)) + ")" + value + line.substring(matcher.end());
      } else {
        if(matcher.group(1).charAt(0) == '(') {
          return line.substring(0, matcher.start()) + " ((" + getType(matcher.group(2)) +
              ") " + matcher.group(1).substring(1) + line.substring(matcher.end());
        } else {
          return line.substring(0, matcher.start()) + " (" + getType(matcher.group(2)) +
              ") " + matcher.group(1) + line.substring(matcher.end());
        }
      }
    }
    return line;
  }
}

Ubuntu 11.04

Fri, 29 Apr 2011 19:10:05 UTC

Just installed it on my laptop and am enjoying unity, still need to get used to it but it looks like a nice alternative to the old gnome 2 window manager.

Updates on minpsp project

Wed, 09 Mar 2011 15:35:58 UTC

Development has slowed down but it is not stalled, for the next release 11.2 you can expect better oslib_mod packages and a diet on the deb files, tests have shown that from more than 150Mb the new deb packages are about 50Mb...

MinPSP Eclipse Plugin @ Google Code

Wed, 09 Mar 2011 15:32:13 UTC

I've been using the MinPSP Eclipse plugin for a while and several people have downloaded it. I see that people are interested in the plugin and I get also requests for new features, such as project templates and better GDB support with the latest Eclipse. Since I don't have much time to work on this myself, I've open sourced the source code of the plugin.

You can get the source code here: minpsp-eclipse-plugin.

If you want to participate and make this plugin better just request it on the project site and I will work out a way for you to help.

New MinPSP plugin 1.0.0

Thu, 03 Feb 2011 19:55:54 UTC

A total refactoring of the plugin is complete, this time the plugin can discover compiler flags and default includes, in order to get it working properly, make sure your minpsp installation is on the path. On windows the installer does this automatically but for other platforms you need to do it yourself.

Once you do this and create a MinPSP lib project/or Makefile project, you will see that default includes get automatically indexed and it can compile out of the box lib projects.

Also a nice addition is that MinPSP debugger gets listed automatically on the debuggers panel.

I will plan to write a new tutorial with the new plugin soon :)

As usual get the plugin from the update site: http://www.jetdrone.com/static/eclipse/update

Sorry, Your Top Speed Wasn't Enough For A High Score

Thu, 27 Jan 2011 13:00:44 UTC

[[photo:http://cache.gawker.com/assets/images/kotaku/2011/01/34.jpg]]

Today is KDE 4.6 release day

Wed, 26 Jan 2011 14:16:08 UTC

[[bookmark:http://www.kde.org/announcements/4.6]]

Ken Thompson, Dennis Ritchie win Japan Prize

Wed, 26 Jan 2011 11:44:29 UTC

[[bookmark:http://www.sfgate.com/cgi-bin/article.cgi?f=/c/a/2011/01/25/BUTI1HDJSA.DTL]]

MinPSP Eclipse Plugin 0.0.1

Fri, 14 Jan 2011 10:36:13 UTC

In order to make your game development environment even more friendly with Eclipse, I am pleased to announce the initial release of the MinPSP Eclipse Plugin. This plugin will allow you to create:

Executable Projects
Static Library Projects
Makefile Projects

It is still very primitive and depends on having the Eclipse C/C++ Development Tools installed. To get started install the plugin by going to its update site:

http://www.jetdrone.com/static/eclipse/update

You should be seeing something like this:

Once the install process completes and Eclipse is restarted you can start creating your projects:

MinPSPW 0.11 is out for Windows Linux and Mac

Tue, 11 Jan 2011 15:46:15 UTC

New release is out, not so many features this time:

openTRI engine devpak
reverted binutils to 2.16 since 2.18 generates bad assembly for Daedalus
supports Mac as a development platform thanks to autilio
Fixed pspsh on win32 when run inside eclipse
added PRXTool

Thanks for the bug reports and enjoy.

binutils 2.18 are broken :(

Sun, 02 Jan 2011 17:41:58 UTC

There is a subtle bug on the binutils 2.18 it is possible to reproduce if you build for example Daedalus PSP emulator, with the current SDK it fails to run, but with the old 0.9.5 or downgraded binutils the generated binary works... This is a very obscure bug that i will try to isolate but if any of the users of MinPSPW can help it would be welcome :)

newlib patches

Fri, 31 Dec 2010 17:39:09 UTC

Lately i have been looking into newlib, although there is again a new release 1.19 i am still looking at 1.18. What is so interesting about it? Well, i have noticed that the pspsdk is using integer math for all it's floating point operations, after studying the documentation is was simple to enable hardware floating point math just by using a configuration flag: --enable-newlib-hw-fp. After this point i've noticed that using the -fast-math with gcc does nothing, why? Apparently newlib only has support (or so it seems to me) for NEC processors, so after a couple of hacking i added basic support for fast math function replacements. I did not add all functions but just some basic ones:

sinf(float x)
cosf(float x)
asinf(float x)
acosf(float x)
atanf(float x)
absf(float x)
sqrtf(float x)
expef(float x)
logef(float x)

The idea here is that just by enabling the -fast-math flag you can benefit from some performance improvement. It is obvious to say that this is all experimental stuff it might work or not with your code, we need to test and see how it behaves. Now, It may be already lots of changes, but something that has been puzzling me for a while is why does ODE (Open Dynamics Engine) work on the PSP, after changing some mails on the ODE mailing list i got some info that NaNs and Infs do not work as expected, so i decided to patch again new lib for that too. Now here is a thing that is more complicated than it sounds. Newlib floating point math has several implementations, ISO, IEEE, X... so which one to change? i opted for the default one, math.h defines 2 functions:

isnan
isinf

These were functions that were changed and remained on math.h as macros, that expand to fpclassify comparisons, however there are 2 extra functions:

__isnanf
__isinff

These ones are real implementations, so i patched these 2 to use the PSP fpu processor to check if a number is NaN or INF. I will be testing this changes but if some of the users of minpsp, you for example :) would like to help to test just build the toolchain and try it out or let me know and i will build a test toolchain for alpha testers.

MinPSP is comming to Mac OS X

Thu, 09 Dec 2010 18:37:53 UTC

Well, people who know me know that Mac's are really not my thing, i am not a fan of Apple products, i never found my iPod easy to use or even iTunes, they always do what Apple wants, not me... anyway this is no reason for ignore the platform and now with help of a very patient ps2dev community we are getting MinPSP also running on that platform. As of today the same toolchain script can build the binutils, gcc, newlib, sdk, gdb and is stopping on usbpsplink, once we solve this devpaks are next and we are done...

Checking the availability of input on stdin

Mon, 29 Nov 2010 09:01:44 UTC

One of the things MinPSP is looking for, is native port of the homebrew SDK for their respective native platforms, so on Windows we have Windows native executables, on Linux we have Linux native executables, on Linux 64bit... you got the idea... One of the annoying things about this is that not all OSes are POSIX, and not all OSes are from Redmond, so there are quite some quirks that need to be fixed with the crancky #ifdef preprocessor statement. In my last revisit to the MinPSP code I tried to work around the lack of select on file descriptors on windows and converted the pspsh.exe binary from a cygwin binary to a 100% windows native. I isolated all socket code, sockets use select to verify the data availability and for the stdin i assumed that using _kbhit() would be enough. And it has been enough for me since for my tests i always used it from the command prompt, however a long time ago i wrote a small booklet explaining how to plug Eclipse IDE with MinPSP to make it easier to fully develop homebrew applications and there i showed how to invoke pspsh.exe from the eclipse tools. So what was the problem with Eclipse and MinPSP pspsh.exe? Well... i totally forgot that eclipse will just start the process and communicate with it via pipes!!! When you have pipes the _kbhit() function will never return a value other than 0. Having this in mind pspsh would never read anything from stdin since all I/O in the application is non blocking. So after long time of googling and testing i found this piece of code:

static int is_pipe = 0;
static HANDLE input_handle = 0;
int input_available()
{
  DWORD nchars;
  /* When using Standard C input functions, also check if there
   is anything in the buffer. After a call to such functions,
   the input waiting in the pipe will be copied to the buffer,
   and the call to PeekNamedPipe can indicate no input available.
   Setting stdin to unbuffered was not enough, IIRC */
  if (stdin->_cnt > 0)
    return 1;
  if (is_pipe)
  {
    /* When running under a GUI, you will end here. */
    if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL))
      /* Something went wrong. Probably the parent program exited.
         Could call exit() here. Returning 1 will make the next call
         to the input function return EOF, where this should be
         catched then. */
      return 1;

    return (nchars != 0);
  }
  else
    return _kbhit() != 0; /* In "text-mode" without GUI */
}

Amazingly this code works for me, and lets me pool stdin from pipe for data available to be read. The only thing missing here is how is the is_pipe variable initialized. I've found 2 ways one using the function _isatty( _fileno(stdin)) or using Win32 API, I've chosen this way:

  DWORD dw;
  input_handle = GetStdHandle(STD_INPUT_HANDLE);
  is_pipe = !GetConsoleMode(input_handle, &dw);

And that was it, now you can handle non blocking input from console and from pipes!!! Hurray!!!

Experimenting with OpenCL and Java

Mon, 01 Nov 2010 10:21:23 UTC

High Performance Computing has been always a research topic for me. I've been looking into it for a while and now that i have upgraded my laptop i own a ATI Radeon HD 4570 I can play with OpenCL. OpenCL looks very nice but it does not really integrates well with Java. I mean there are several bindings but their APIs do not seem natural to Java. It was until a few weeks ago that I found the AMD Java Zone Research Aparapi project. I decided to give Aparapi a try and installed it on my Kubuntu 10.10. Honestly I was impressed with the simplicity of the installation. I've downloaded:

Since i already had the proprietary driver from AMD installed with Kubuntu, i just unziped the Stream SDK into my home, the icd-registration to the root of the file system and the Aparapi SDK to my home. And it just works!!! I gave it a try and here is my Kernel for a bitonic sort using Aparapi:

public class BitonicSortKernel extends Kernel {

  int[] theArray;
  int stage;
  int passOfStage;
  int width;
  int direction;

  @Override
  public void run() {
    int sortIncreasing = direction;
    int threadId = getGlobalId();

    int pairDistance = 1 << (stage - passOfStage);
    int blockWidth   = 2 * pairDistance;

    int leftId = (threadId % pairDistance)
        + (threadId / pairDistance) * blockWidth;

    int rightId = leftId + pairDistance;

    int leftElement = theArray[leftId];
    int rightElement = theArray[rightId];

    int sameDirectionBlockWidth = 1 << stage;

    if((threadId/sameDirectionBlockWidth) % 2 == 1)
        sortIncreasing = 1 - sortIncreasing;

    int greater = rightElement;
    int lesser = leftElement;

    if(leftElement > rightElement)
    {
      greater = leftElement;
      lesser  = rightElement;
    }

    if(sortIncreasing != 0)
    {
      theArray[leftId]  = lesser;
      theArray[rightId] = greater;
    }
    else
    {
      theArray[leftId]  = greater;
      theArray[rightId] = lesser;
    }
  }
}

This was a good exercise to experiment with Aparapi, the SDK contains more samples, a squares compute and a mandelbrot fractal.

Confiscated video game machines used for gambling (China)

Fri, 08 Oct 2010 10:29:55 UTC

[[photo:http://www.jetdrone.com/media/2]]

Allegro 4.4 will be on the next MinPSPW release

Sun, 29 Aug 2010 09:09:13 UTC

You can start porting your allegro games to the PSP, allegro 4.4.1.1 will be part of the next MinPSPW release, although AllegroGL is not included.

MinPSPW has gone to Mars

Fri, 27 Aug 2010 17:38:05 UTC

Long time ago it was possible to write homebrew code for the PlayStation Portable using the D Programming Language, however with the upgrade of GCC to the 4.1, 4.2 and later on to 4.3 the patch didn't work anymore. During the last month I've been studying the GDC bitbucket project and trying to port it back to the MinPSPW toolchain. Although it seemed trivial, because the new GDC project has updated the patch for GCC 4.3 it proven not practical for the cross toolchain. After patching a lot of stuff I finally have a build for now only on Linux that can compile and link a simple Hello World example.

So for now on it will be possible to write code such as:

// imports
// extern (C) allows D to call C functions directly, no need to wrap
extern (C) void pspDebugScreenInit();
extern (C) void pspDebugScreenPrintf(char*,...);
extern (C) int SetupCallbacks();
extern (C) int sceKernelSleepThread();

import std.string;

class HelloPsp
{
public:
    void sayHello()
    {
        pspDebugScreenPrintf(toStringz(m_msg));
    }
    char[] m_msg = "Hello D on Psp\n";
}

int main()
{
    SetupCallbacks();

    pspDebugScreenInit();
    
    auto hello = new HelloPsp();
    hello.sayHello();

    sceKernelSleepThread();
    return 0;
}

So why D? D is a systems programming language. Its focus is on combining the power and high performance of C and C++ with the programmer productivity of modern languages like Ruby and Python. Special attention is given to the needs of quality assurance, documentation, management, portability and reliability.

The D language is statically typed and compiles directly to machine code. It's multiparadigm, supporting many programming styles: imperative, object oriented, and metaprogramming. It's a member of the C syntax family, and its appearance is very similar to that of C++.

I am planning to update the toolchain and start testing with Windows to be released once the new Ubuntu version is out.

MinPSPW project update

Sat, 19 Jun 2010 17:59:26 UTC

It has been a long while since the last update to the MinPSPW. I haven't stop it, although if you really want to start an indy game studio you can subscribe to the PSP minis. But for the kick and for the people who are just amateurs you can use the Homebrew SDK. The upcoming release 0.9.6 will contain:

pspsh does not depend on cygwin and is native
remotejoy SDL is also included as a native binary (no cygwin)
win32 dependencies updated
zlib 1.2.5
SDL 1.2.14
readline 5.1 (same as gdb)
libiconv 1.13.1
pthreads 2.8.0
updated the fpulib trig functions can use the FPU processor but we either use vfpu or software impl using libm. This can help to make a bit faster code if we do not need vectors.
Updated newlib to 1.18
wide-char enhancements
long double math routines added for platforms where LDBL == DBL
long long math routines added
math cleanup
major locale charset overhaul including added charsets
various cleanups
various bug fixes
Updated the dev environment to build under Windows Vista and Windows 7
Updated binutils to 2.18 (for better integration with gcc 4.3.x)
removed the patch that defines long as 64bit back to 32bit. This can lead to faster code but breaks old compiled libraries
Disabled CDT-5.0.x bug fix
gcov builds properly but not fully tested if works as expected
added fixes from Luqman Aden in TinyXML
added libmpeg2 devpak
added bullet physics devpak
windows tools are linked against pthreads, if thereads are used it can improved performance on the development side.

This has been an incredible exercise since I've learned a lot of the win32 API while porting the network code from pspsh and remotejoy to windows. I still need time or help to port the psplinkusb_pc to use winusb API.

Performance performance performance!!!

Fri, 19 Mar 2010 22:46:01 UTC

So as I have written before I've been playing with maps and renderers and found this very interesting thing. My old home laptop which is a 5 year old Sony VAIO FE11S with a intel T2400 CoreDuo 1.86GHz CPU, 2GB ram and a NVIDIA GeForce Go 7400 256MB is as fast a Intel XEON E5520 with 8GB ram and ATI FirePro v5700 video card. I've run the code on both machines and the difference is minimal, so what is wrong here? Well after testing there is nothing wrong on the code, there are no dead locks or threads waiting for each other. What is wrong is the video card drivers. On my VAIO I still have Windows XP SP3 and a NVIDIA driver from 2006 (because Sony doesn't allows me to install the latest from NVIDIA). On the fast desktop I have Ubuntu 64 bit with the crappy ATI proprietary driver. This ATI driver is the key here since on Windows all my rendering is done using Java2D with the DirectDraw pipeline on and it is amazingly fast, it is also true if I use the OpenGL pipeline but the OpenGL driver is not as good as DirectX. On linux the driver is so crap that all rendering is done in software and a machine which I expected to be say 10x faster (it has 6x more cores, it is 64bit and the OS is also 64bit) it just sucks.

Fast 2D render

Sat, 13 Mar 2010 20:31:51 UTC

In the last couple of weeks I started a research activity around map rendering. I know that there is plenty of map renderers, and that Mapnik is pretty good, however I wanted to experiment so I need something simple yet fast. This lead me to research on 2D rendering libraries. Libraries that are free since I have to budget and portable since I work mostly with Linux and sometimes with Windows.

After googling for a while I found 2 big libraries:

Cairo Graphics
AntiGrain Geometry

The first one is C and the second C++ of course I'd go with the first, I do prefer C over C++ but that could be a topic for other post. These libraries are pretty impressive but I wanted something portable and that is when I have found OpenVG. The concepts behind OpenVG made me think, WOW I want it, so I started a quest for a implementation that was not software based... and I couldn't find one... at least for free.

Facing this setback I decided to research how does java and the jvm fix this problem. Having seen the latest versions of Netbeans they must have some optimized code to make all that swing code fast, so I started looking into Java2D. Searching the web I found lots of opinion pages saying that Java is slow, Java2D is slow but still I wanted to give it a try. After going over the 2D tutorial I found out that in fact Java2D can benefit from hardware acceleration. On Windows acceleration is achieved through DirectDraw and on Linux through OpenGL. According to the tutorial one can request accelerated rendering operations by hinting the jvm that our target image should be accelerated like this:

GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
GraphicsConfiguration gc = ge.getDefaultScreenDevice().getDefaultConfiguration();
BufferedImage img = gc.createCompatibleImage(width, height, Transparency.TRANSLUCENT);
img.setAccelerationPriority(1);

We create a BufferedImage that matches our graphic configuration so the chances that we end up this image on VRAM are bigger and then hint the JVM that it should accelerate it. This by itself already brings performance improvement but if we really want fast images there is another kind of image, the VolatileImage. This kind of image is saved in a OpenGL pbuffer and on windows it can be really volatile. This means that even though you are drawing into it it may end up clobbered by other application that needed to write into the VRAM. This kind of image is really fast but has the inconvenient that it cannot be used directly with the ImageIO class to write to disk, you still need to create a BufferedImage to write to and then you can save.

GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
GraphicsConfiguration gc = ge.getDefaultScreenDevice().getDefaultConfiguration();
VolatileImage vImage = gc.createCompatibleVolatileImage(width, height, Transparency.TRANSLUCENT);

It is up to you how fast you need your images to be...

New blog, new life

Sat, 13 Mar 2010 20:03:58 UTC

This site is run by Paulo Lopes. I used to run jetcube.eu blog but due to a series of inconvenient accidents, the old blog, post and comments got lost. I will try to dump here knowledge that I acquire from my daily software development actions in video game and systems software hacking.