I appreciate all the insight as to how it works.

Here it is the finished JPCTFilmGrain.java file
I apologize for the lack of documentation. I just feel lazy for something I was goofing around with
/** FilmGrain
This api is designed to give an old time cinematic feel to images or animated
scenes. Also useful for in games effects like poor reception TV .

@author Jason T. Jarvis
@version  %I%, %G%
*/

package jpctfx;

import java.util.Random;
import java.awt.image.BufferedImage;

import com.threed.jpct.Texture;
import com.threed.jpct.TextureManager;
import com.threed.jpct.FrameBuffer;


public class JPCTFilmGrain
{
  public static final int QUALITY_HIGH = 256;
  public static final int QUALITY_GOOD = 128;
  public static final int QUALITY_MEDIUM = 64;
  public static final int QUALITY_LOW = 32;
  public static final int QUALITY_VERYLOW = 16;
  
  private int _alpha = 20;
  private int _quality = QUALITY_HIGH;
  private int _frames = 3;
  private int _currentFrame = 0;
  private int _duration = 3;
  private int _durationCount = 0;
  private boolean _colourGrain = false;
  private int[][] _ptexture;
  private Texture[] _texture;
  
  public JPCTFilmGrain(boolean initialize)
  {
    if(initialize) init();
  }
  
  public void setAlpha(int alpha)
  {
    alpha = alpha < 0 ? 0   : alpha;
    alpha = alpha > 255? 255: alpha;
    
    _alpha = alpha;
  }
  
  public void setQuality(int quality)
  {
    quality = quality < 1 ? 1 : quality;
    quality = quality > 256? 256: quality;
    
    _quality = quality;
  }
  
  public void setFrames(int frames)
  {
    _frames = frames < 1 ? 1 : frames;
  }
  
  public void setDuration(int duration)
  {
    _duration = duration < 1? 1 : duration;
  }
  
  public void colourGrain(boolean on)
  {
    _colourGrain = on;
  }
  
  public void setTexture(int index, Texture tex)
  {
    if(index >= _texture.length)
      index = index % _texture.length;
    
    TextureManager.getInstance().removeTexture("FilmGrain"+index);
    TextureManager.getInstance().addTexture("FilmGrain"+index, tex);
    _texture[index] = tex;
  }
  
  
  public int getAlpha(){ return _alpha; }
  public int getQuality(){return _quality;}
  public int getNumFrames(){return _frames;}
  public int getDuratoin(){return _duration;}
  public int getCurrentFrame(){return _currentFrame;}
  public int getDurationCount(){return _durationCount;}
  public boolean isColour(){return _colourGrain;}
  public int[][] getPixelTextureArray(){return _ptexture;}
  public int[] getPixelTexture(int index){return _ptexture[index];}
  public Texture getTexture(int index){return _texture[index];}
  public Texture[] getTextureArray(){return _texture;}
  
  
  public void init()
  {
    _texture = new Texture[_frames];
    _ptexture= new int[_frames][_quality * _quality];
    BufferedImage src;
    
    for(int i = 0; i < _frames; i++)
    {
      src = new BufferedImage(_quality, _quality, BufferedImage.TYPE_INT_ARGB);
      _ptexture[i] = createGrain(src);
      _texture[i] = new Texture(src, true);
      TextureManager.getInstance().removeTexture("FilmGrain"+i);
      TextureManager.getInstance().addTexture("FilmGrain"+i, _texture[i]);
    }
  }
  
  
  
  public void apply(FrameBuffer buffer)
  {
    if(_durationCount >= _duration)
    {
      _currentFrame++;
      
      if(_currentFrame >= _frames)
      {
        _currentFrame = 0;
      }
    }
    
    if(_texture[_currentFrame] == null)
    {
       return;
    }

    buffer.blit(_texture[_currentFrame],
      0, 0, 0, 0,
      _quality, _quality,
      buffer.getOutputWidth(),
      buffer.getOutputHeight(),
      0, false, null);
      
    _durationCount++;
  }
  
  private int[] createGrain(BufferedImage image)
  {
    int argb;
    int r, g, b;
    int pixels[] = new int[_quality * _quality];
    Random random = new Random();
    
    for(int i = 0, y = 0; y < _quality; y++)
    {
      for(int x = 0; x < _quality; x++)
      {
        r = random.nextInt(256);
        g = _colourGrain ? random.nextInt(256) : r;
        b = _colourGrain ? random.nextInt(256) : r;
        
        argb = ( (_alpha<<24) | (r<<16) | (g<<8) | b );
        
        pixels[i++] = argb;
        
        image.setRGB(x, y, argb);
      }
    }
    
    return pixels;
  }
  
}

How to use it
The easiest way is to call the default settings. This creates a default number of frames, quality and duration in the grey scale.
               filmgrain = new JPCTFilmGrain(true);

There are however more options to allow for custom settings. Different resolutions, art styles colours can impact the effect FilmGrain has.
filmgrain = new JPCTFilmGrain(false);
filmgrain.setFrames(5);
filmgrain.setDuration(3);
filmgrain.setAlpha(20);
filmgrain.setQuality(JPCTFilmGrain.QUALITY_HIGH);
filmgrain.colourGrain(true);
filmgrain.init();
First start by not allowing the default initialization. Pass  a false value to the constructor. Everything is optional as all of them have default values. Only the last line init() is required. The default vales are within the parameter.

setFrames(3) determines the number of static images to be created and cycle through.
setDuration(3) determines how many calls go by before the next static frame is used.
setAlpha(20) determines the transparency of the static frame. 0 should be full while 255 is solid.
setQuality(256) quality of the grain or size of the texture. There is QUALITY_HIGH|GOOD|MEDIUM|LOW. 256|128|64|32.
colourGrain(false) uses colours as the grain rather than grey scale.

init() must be called before use if not using the initialize/true parameter.

How to apply the grain
buffer.clear();
world.renderScene(buffer);
world.draw(buffer);
   buffer.update();

filmgrain.apply(buffer);   // <==== HERE

buffer.display(frame.getGraphics());
yep, just one line before the display is drawn to the screen. That is right. Minimally it only takes three lines of code to get FilmGrain into your projects(don't forget to import). Have fun downgrading

ok thanks. I did some test and here is what I came up with.

Using the alpha value in the blit doesn't do anything with the png or created texture.

Doing a Texture.setAlpha(anything) will causes the texture to not render at all. Same for a PNG or create texture.

A png with a defined transparent spot will be transparent. So all the "white" around the tank and legs are see through. The rest of the fishtank has no transparency in any level of alpha. So the tank, fish and legs block the scene.

edit: correction. If the alpha is set to less than 10 or so. you can barely see past texture. Past that it's pretty much blocked.

yep, posting again. Posting seems to help either by getting some one smarter to to let me try something; or posting helps me put things into perspective to try something else to figure it out.

Anyways. I've managed some progress. I can now blit the static onto the screen. except now you can't see anything but static(reminds me of growing up ).


src = new BufferedImage(256, 256, BufferedImage.TYPE_INT_RGB);
createGrain(src);
_texture[i] = new Texture(src, true);
TextureManager.getInstance().addTexture("FilmGrain"+i, _texture[i]);
Removing the setAlpha() now let's me see it. setting the alpha to anything would show nothing. I also using RGB or ARGB with no difference in effect.


heres the blit line
    buffer.blit(_texture[_currentFrame],
      0, 0, 0, 0,
      _quality, _quality,
      _width, _height,
      _alpha, false, null);
Alpha can be anything and it will have no effect.

sorry this was my entire render loop
buffer.clear(java.awt.Color.BLUE);
world.renderScene(buffer);
world.draw(buffer);

  buffer.update();
  filmgrain.apply(buffer.getGraphics(), frame);
  dynamicWorld.debugDrawWorld();
buffer.display(frame.getGraphics());


I did finally find it. I was scaling wrong or more to the point I wasn't scaling at all

I still can't imagine anyone wanting to reduce there image quality, but if for some reason some one wants to try and get that old time cinematic feel here is the code. It's direct post effect. I'll do a JPCT version some point in the future using buffer.blit(Texture....) for better speed results.
/** FilmGrain
This api is designed to give an old time cinematic feel to images or animated
scenes.

@author Jason T. Jarvis
*/

import java.util.Random;
import java.awt.image.BufferedImage;
import java.awt.Graphics;
import java.awt.geom.*;

import java.awt.*;
import java.awt.image.*;


public class FilmGrain
{
  public static final int QUALITY_HIGH = 1;
  public static final int QUALITY_GOOD = 2;
  public static final int QUALITY_MEDIUM = 4;
  public static final int QUALITY_LOW = 8;
 
  private int _width = 1;
  private int _height = 1;
  private int _sWidth;
  private int _sHeight;
  private int _alpha = 50;
  private int _quality = 1;
  private int _frames = 1;
  private int _currentFrame = 0;
  private int _duration = 1;
  private int _durationCount = 0;
  private BufferedImage[] _texture;
 
  public FilmGrain(int width, int height)
  {
    _width = width;
    _height = height;
    init();
  }
 
  public FilmGrain(int frames, int width, int height)
  {
    _frames = frames;
    _width = width;
    _height = height;
    init();
  }
 
  public void setAlpha(int alpha)
  {
    if(alpha < 0 || alpha > 255)
      alpha = _alpha;

    _alpha = alpha;
  }
 
  public void setQuality(int quality)
  {
    if(quality < 1 || quality > 64)
      quality = _quality;
   
    _quality = quality;
  }
 
  public void setGrainFrames(int frames)
  {
    if(frames < 1 || frames > 10)
      frames = _frames;
   
    _frames = frames;
  }
 
  public void setDuration(int duration)
  {
    if(duration < 1)
      duration = _duration;

    _duration = duration;
  }
 
  public void init()
  {
    _texture = new BufferedImage[_frames];
    _sWidth = _width / _quality;
    _sHeight = _height / _quality;
   
    for(int i = 0; i < _frames; i++)
    {
      _texture[i] = new BufferedImage(_sWidth, _sHeight, BufferedImage.TYPE_INT_ARGB);
      createGrain(_texture[i]);
    }
  }
 
 
 
  public void apply(Component c)
  {
    Graphics g = c.getGraphics();
   
    if(_durationCount >= _duration)
    {
      _currentFrame++;
      if(_currentFrame >= _frames)
      {
        _currentFrame = 0;
      }
    }
   
    g.drawImage(_texture[_currentFrame],
      0, 0, _width, _height,
      0, 0, _sWidth, _sHeight,
      c);
   
    _durationCount++;
  }
 
  public void apply(Graphics g, Component c)
  {
    if(_durationCount >= _duration)
    {
      _currentFrame++;
      if(_currentFrame >= _frames)
      {
        _currentFrame = 0;
      }
    }
   
    g.drawImage(_texture[_currentFrame],
      0, 0, _width, _height,
      0, 0, _sWidth, _sHeight,
      c);
   
    _durationCount++;   
  }

  public static BufferedImage scale(BufferedImage bsrc, int width, int height){
    BufferedImage bdest =
      new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
   Graphics2D g = bdest.createGraphics();
   AffineTransform at =
      AffineTransform.getScaleInstance((double)width/bsrc.getWidth(),
          (double)height/bsrc.getHeight());
   g.drawRenderedImage(bsrc,at);
   return bdest;
  } 
 

  private void createGrain(BufferedImage image)
  {
    int argb;
    int r, g, b;
    int size =  width * height;
    int pixels[] = new int[size];
    Random random = new Random();
   
    for(int i = 0, y = 0; y < _sHeight; y++)
    {
      for(int x = 0; x < _sWidth; x++)
      {
        r = random.nextInt(256);
        g = random.nextInt(256);
        b = random.nextInt(256);
        argb = ( (_alpha<<24) | (r<<16) | (r<<8) | r );
        //argb = ( (_alpha<<24) | (r<<16) | (g<<8) | b );
        //pixels[i++] = argb;
        image.setRGB(x, y, argb);
      }
    }
  }
 
}
* If you want to have coloured grain use the implemented version of rgb bit shift not the rrr
** You can also use the pixels[] for creating a JPCT Texture. which is of course commented out.




How it works
filmgrain = new FilmGrain(800, 600);

filmgrain.apply([frame/applet/Component]);
This will create a single frame grain on a 1:1 size. Then apply will affect the graphics of the object.

This is 3d engine site. So a single frame is somewhat pointless. So here is how to apply it to the JPCT for animation
filmgrain = new FilmGrain(800, 600);
filmgrain.setGrainFrames(5);
filmgrain.setDuration(3);
filmgrain.setAlpha(50);
filmgrain.setQuality(FilmGrain.QUALITY_MEDIUM);
filmgrain.init();
Create a new grain.
Set how main different grain frames you want.
Set how many frames(apply() ) do you want each frame to stay. This is in frame draws not time. Default is 1.
Setting the alpha. It seems the lower the quality the higher the alpha should be set. 50 seems ideal. 50 is also default so it's not needed to set.
Set the quality(QUALITY_HIGH/GOOD/MEDIUM/LOW) . MEDIUM seems to work well for 3d rendering. Higher the quality slower it will run.
init() recreates the buffers.

And here is the line to integrate it. It's meant to be easy as possible.
       world.renderScene(buffer);
       world.draw(buffer);

       filmgrain.apply(buffer.getGraphics(), [Component|Frame|Applet]);

        buffer.update();
        buffer.display(frame.getGraphics());


ooohhh, theres some nice changes in there a lot of them too.

sigh

I'm interested in this too. At some point. I was working on trying to get some water rendering working, but my math skills were far lacking in understanding complex numbers for Fast Fourouir Transforms to understand it or how to translate it to code. So i'm taking a break and weak by weak pick up my math skills.

In the mean time. I would suggest "Planar mirrors for local reflections" @ (http://www.gamedev.net/reference/articles/article2138.asp).

It has lot's of discussion on how to do water. And no water reflection is not a default feature of graphics cards. It is however becoming a more accessible middle ware for C++/DX/OLG. Java is a bit behind.

JME does have a water demo that your looking for however. http://www.youtube.com/watch?v=UVbKNUaYuBk
The video shows landscape reflection. They also have a few water features.

ooohhhh, thank you. I think I've been looking for this

SimpleVector Interact2D.project3D2D(Camera camera, FrameBuffer buffer, SimpleVector vertex)

I'm going out on an assumption that this takes a 3d world vertex and gives 2d screen. that's what it says and that sounds like exactly what I was looking for. I tried looking in the various Renderes, but didn't find what I was looking for. If this works you can have a virtual hug

So I get a 2d reference in the return type. Then I draw on the FrameBuffer IIRC.