that looks really nice good job.

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

Thanks that solves it all. I thought the blit alpha was along the standard 0-255 scale. setting it 0 has done wonders.

I'll post the JPCTFilmGrain code after some clean up and polish. Though I thought that using JPCT I could get really fast blitting. it seems not so much. I think FilmGrain might have to stick with hardware rendering for best effect. At which point it would be just better to use GLSL.

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, it's the software renderer. I'll try out the idea of test png when I get the chance.

Thanks

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.

 ugg, me sucky at JPCT buffer images.



src = new BufferedImage(256, 256, BufferedImage.TYPE_INT_ARGB);
createGrain(src);
_texture[i] = new Texture(src, true);
_texture[i].setAlpha(_alpha);
TextureManager.getInstance().addTexture("FilmGrain"+i, _texture[i]);


here is the blit code

    buffer.blit(_texture[_currentFrame],
      0, 0, 0, 0,
      _quality, _quality, true);
   
    buffer.blit(_texture[_currentFrame],
      0, 0, 0, 0,
      _quality, _quality,
      _width, _height,
      _alpha, true, new Color(0,0,0)); // color is created else where, but I thought I would just show that's it's set to 0 0 0


the top one works, but only blits width/height  as it's supposed to.

The bottom one doesn't work. but it's the bottom one that scales the image.

any idea on what I'm doing wrong?

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());


So I said to myself, what the heck let's try some of that film grain. I am starting by trying to create a generic post process that's non engine based. So it's a direct to graphics draw with no other apis involved. Later I figure i'll do a JPCTFilmGrain version.

Though I could use some help on this.

Heres my FilmGrain code. It can generate a few images of grey scale static. Quality depending on choice. lower the better.

/** FilmGrain
This api is designed to give an old time cinematic feel to images or animated
scenes.

@author Jason T. Jarvis
*/

package sre.gfx;

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

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


public class FilmGrain
{
  private int _width = 1;
  private int _height = 1;
  private int _alpha = 50;
  private int _quality = 32;
  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];
   
    for(int i = 0; i < _frames; i++)
    {
      _texture[i] = new BufferedImage(_width, _height, 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, 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, c);
   
    _durationCount++;   
  }


  private void createGrain(BufferedImage image)
  {
    int argb = 0x000000;// 0x 00 00 00 00
    int r, g, b;
    int width = (int)_width / _quality;
    int height = (int)_height / _quality;
    int size =  width * height;
    int pixels[] = new int[size];
    Random random = new Random();
   
    for(int i = 0, y = 0; y < height; y++)
    {
      for(int x = 0; x < width; x++)
      {
        r = random.nextInt(256);
        //g = random.nextInt(256);
        //b = random.nextInt(256);
        argb = ( (_alpha<<24) | (r<<16) | (r<<8) | r );
        pixels[i++] = argb;
        image.setRGB(x, y, argb);
        //System.out.println(argb);
      }
    }
    //image.setRGB(0, 0, _width, _height, pixels, offset, scanline);
  }
 
}


Here is the implementation code

--- initilization
filmgrain = new FilmGrain(800, 600);
filmgrain.setGrainFrames(3);
filmgrain.setDuration(3);
filmgrain.setAlpha(200);
filmgrain.setQuality(32);
filmgrain.init();


--- render loop
  dynamicWorld.debugDrawWorld();
          filmgrain.apply(buffer.getGraphics(), frame);
buffer.display(frame.getGraphics());


the problem is that I don't see anything. I have increased the alpha by a lot so I know there is some visible blitting happening and it's just not light. but there pretty much nothing. though the fps drops a lot when filmgrain.apply() is used. so the drawing does seem to happen.

am I drawing wrong or something?

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

Answer is ummm, maybe.

Seems to sorta work. but now I have to wonder if i'm still rotating Object3D wrong or i'm drawing the debug wrong.

edit:
Wheel A makes sense, but in the samples this may not be what's happeing.
Wheel B is what is happening visually. The box rotates one way, very smoothly for a box?
Wheel C is what i'm getting from the axis debug drawing. the box is flat and spinning along the z axis, but graphicly it looks more like B.

I can see C happening because I have very little friction. so a spinning box on the side while sliding in a direction makes sense. but it looks like the box is rotating in example B.

anyone have any thoughts. Yes the debug could be wrong, but the interaction along the axis seems to look more accurate that the graphical boxes. I have rotates the graphical box along the X to invert ZY.

edit:
finally got it. It was a piece of code I left in that I didn't need. It did something with the matrix before graphic processing. rotation issue seems sovled.

Though too note. ZY rotation axis is upside, but behaves correctly in regards to binding. I don't see this being a problem in implementation of the physics engine.

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.

Hey Egon or any 3d guy

Alrighty then. So I've been working on IDebugDraw to some success and some bizarre failure. After some experiments I figure the next step to do is some trigonomtry or maybe cheap pretendy, but not real trig.

I am passed 2 Vector3f. They are similar to SimpleVector so no worries. They represent world coordinates, a vertex. Before I convert them over to screen. I need to rotate pointB around pointA along the ZY axis.

public void drawLine(Vector3f from, Vector3f to, Vector3f color)

My trig is lousy, but here was my thought in psuedo


vertex = to - from                  // i'm hoping that this will treat the new vertix around a point 0/0/0
vertex.y/z = -vertex.y/z                                //i'm reversing yz
To = vertex + from



The reason i'm doing this is because all the lines in the debugdrawing are well wrong. The (RGB)axis lines YZ are wrong.  Now I wouldn't mind them being just backwards. I can handle them just backwards. The problem arises that if a box rotates along the Y axis by  1.0. The graphical box goes one way, but the axis lines are going the other.

I'm sure if the wireframe on the debug drawing worked it would probably cause all sorts of mistaken rotation lines. But they are not so I might as well address the axis lines first.

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.

Thanks. I looked it up some more just a bit ago. I have seen some posts around websites saying that MotionBlur being done by GLSL and mentions of IPostProcessor.

I love film grain effect, though I tend to turn it off. I find it slows down the game and I don't have anything near a cutting edge system. I tend to buy the budget $350 computer every 2/3 years  :\ with a graphics card and memory upgrade every other year. Again budget wise     As for implementation of filmgrain. I'm not sure if it's the best way, but thats the way I was reading it for video production. I can see doing it that way with rendering being easy. Though maybe as mentioned it can be done with IPostProcessor too.

I was more curios about the idea right now. I don't think I will be implementing these(especially Motion Blur) until I have something more playable. Currently I'm working in software more for the applet to reduce load times for testing.  Thanks for the replies. I will certainly look into at hopefully some point soon