Posted by platinumthinker on Dec 08, 2012; 12:48pm
URL: https://forum.jogamp.org/Problem-with-memory-tp4027447p4027454.html

import com.jogamp.opencl.*;                                                                                                            
                                                                                                                                       
import javax.swing.*;                                                                                                                  
import java.awt.*;                                                                                                                    
import java.awt.event.MouseEvent;                                                                                                      
import java.awt.event.MouseMotionListener;                                                                                            
import java.awt.event.WindowAdapter;                                                                                                  
import java.awt.event.WindowEvent;                                                                                                    
import java.awt.image.BufferedImage;                                                                                                  
import java.io.IOException;                                                                                                            
import java.nio.FloatBuffer;                                                                                                          
import java.nio.IntBuffer;                                                                                                            
                                                                                                                                       
import static java.lang.Math.min;                                                                                                      
                                                                                                                                       
/**                                                                                                                                    
 * Created by IntelliJ IDEA.                                                                                                          
 * User: thinker                                                                                                                      
 * Date: 18.11.12                                                                                                                      
 * Time: 3:42                                                                                                                          
 */                                                                                                                                    
                                                                                                                                       
public class RenderGPU extends JFrame                                                                                                  
{                                                                                                                                          
    int height, width;                                                                                                                
    private BufferedImage bufferedImage;                                                                                              
    private boolean isRunning = true;                                                                                                  
    CLCommandQueue queue;                                                                                                              
    CLContext context;                                                                                                                
                                                                                                                                       
    CLBuffer<FloatBuffer> cam_points;                                                                                                  
    CLBuffer<IntBuffer> image;                                                                                                        
                                                                                                                                       
    private int[] pixels;                                                                                                              
                                                                                                                                       
    private int elementCount;                                                                                                          
    int x = -10, y = -10;                                                                                                              
    private CLKernel kernel;                                                                                                          
                                                                                                                                       
                                                                                                                                       
    public RenderGPU(l)                                                                                                
    {                                                                                                                                              
        height = 500;                                                                                                        
        width = 500;                                                                                                                      
                                                                                                                                       
//        color_buffer = new byte[width][height][4];                                                                                    
//        depth_buffer = new float[width][height];                                                                                      
//        normal_buffer = new float[width][height];                                                                                      
                                                                                                                                       
//        light = new OmniLight();                                                                                                      
//        light.point = new Vector(0,1,1);                                                                                              
//        light.color = new Color(255, 253, 244);                                                                                        
                                                                                                                                       
//        buffer = new VoxelBuffer(model);                                                                                            
//        System.out.println("Finish buffering...");                                                                                  
                                                                                                                                       
        setSize(width, height);                                                                                                        
        setLocation(700, 0);                                                                                                          
        setCursor(getToolkit().createCustomCursor(new BufferedImage( 1, 1, BufferedImage.TYPE_INT_ARGB ), new Point(), null));        
        setVisible(true);                                                                                                              
                                                                                                                                       
        addWindowListener(new WindowAdapter()                                                                                          
        {                                                                                                                              
            @Override                                                                                                                  
            public void windowClosing(WindowEvent e)                                                                                  
            {                                                                                                                          
                isRunning = false;                                                                                                    
                context.release();                                                                                                    
                System.exit(0);                                                                                                        
            }                                                                                                                          
        });                                                                                                                            
                                                                                                                                       
        addMouseMotionListener(new MouseMotionListener()                                                                              
        {                                                                                                                              
            @Override                                                                                                                  
            public void mouseDragged(MouseEvent e)                                                                                    
            {                                                                                                                          
                x = e.getX();                                                                                                          
                y = e.getY();                                                                                                          
            }                                                                                                                          
                                                                                                                                       
            @Override                                                                                                                  
            public void mouseMoved(MouseEvent e)                                                                                      
            {                                                                                                                          
                x = e.getX();                                                                                                          
                y = e.getY();                                                                                                          
                System.out.println(x+" "+y);                                                                                          
            }                                                                                                                          
        });                                                                                                                            
                                                                                                                                       
        initCL();                                                                                                                      
                                                                                                                                       
        add(new JLabel(new ImageIcon(bufferedImage)));                                                                                
        setSize(500, 500);                                                                                                            
        pack();                                                                                                                        
                                                                                                                                       
        new Runnable()                                                                                                                
        {                                                                                                                              
            @Override                                                                                                                  
            public void run()                                                                                                          
            {                                                                                                                          
                while (isRunning)                                                                                                      
                {                                                                                                                      
                    long time = System.currentTimeMillis();                                                                            
                    renderFrame();                                                                                                    
                    repaint();                                                                                                        
                                                                                                                                       
                    sleep(20 - (System.currentTimeMillis() - time));                                                                  
                    setTitle(String.format("FPS %f", 1000./(System.currentTimeMillis() - time)));                                      
                }                                                                                                                      
            }                                                                                                                          
        }.run();                                                                                                                      
    }                                                                                                                                  
                                                                                                                                       
    private void sleep(long time)                                                                                                      
    {                                                                                                                                  
        if(time < 1)                                                                                                                  
            return;                                                                                                                    
                                                                                                                                       
        try                                                                                                                            
        {                                                                                                                              
            Thread.sleep(time);                                                                                                        
        } catch (InterruptedException e)                                                                                              
        {                                                                                                                              
            e.printStackTrace();                                                                                                      
        }                                                                                                                              
    }                                                                                                                                  
                                                                                                                                       
    public void stop()                                                                                                                
    {                                                                                                                                  
        isRunning = false;                                                                                                            
    }                                                                                                                                  
                                                                                                                                       
    private void renderFrame()                                                                                                        
    {                                                                                                                                  
        queue.put1DRangeKernel(kernel, 0, elementCount, 0)                                                                            
            .putReadBuffer(image, true).finish();                                                                                      
                                                                                                                                       
        image.getBuffer().get(pixels);                                                                                                
        image.getBuffer().rewind();                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                 
        bufferedImage.getRaster().setPixels(0, 0, width, height, pixels);                                                              
    }                                                                                                                                  
                                                                                                                                       
    public CLDevice getCompatibleDevice()                                                                                              
    {                                                                                                                                  
                                                                                                                                       
        CLPlatform[] platforms = CLPlatform.listCLPlatforms();                                                                        
        for (CLPlatform platform : platforms)                                                                                          
        {                                                                                                                              
            CLDevice[] devices = platform.listCLDevices();                                                                            
                                                                                                                                       
            for (CLDevice device : devices)                                                                                            
            {                                                                                                                          
                if(device.isImageSupportAvailable())                                                                                  
                {                                                                                                                      
                    return device;                                                                                                    
                }                                                                                                                      
            }                                                                                                                          
        }                                                                                                                              
                                                                                                                                       
        return null;                                                                                                                  
    }                                                                                                                                  
                                                                                                                                       
    private void initCL()                                                                                                              
    {                                                                                                                                  
        elementCount = width * height;                                                                                                
                                                                                                                                       
        CLDevice device = getCompatibleDevice();                                                                                      
        context = CLContext.create(device);                                                                                            
                                                                                                                                       
        try{                                                                                                                          
            System.out.println("using " + device);                                                                                    
                                                                                                                                       
            queue = device.createCommandQueue(CLCommandQueue.Mode.PROFILING_MODE);                                                    
                                                                                                                                       
            pixels = new int[elementCount * 3];                                                                                        
                                                                                                                                       
            CLProgram program = context.createProgram(ClassLoader.getSystemResourceAsStream("RayCasting/color.cl")).build();          
                                                                                                                                       
            image = context.createIntBuffer(elementCount * 3, CLMemory.Mem.WRITE_ONLY);                                                
            kernel = program.createCLKernel("color").putArg(image).rewind();                                                          
                                                                                                                                       
            System.out.println(program.getBuildStatus(device));                                                                        
            System.out.println(program.getBuildLog());                                                                                
                                                                                                                                       
            bufferedImage = new BufferedImage(width, height, BufferedImage.TYPE_3BYTE_BGR);                                            
        } catch (IOException e)                                                                                                        
        {                                                                                                                              
            e.printStackTrace();                                                                                                      
        }                                                                                                                              
    }                                                                                                                                  
                                                                                                                                                                                                                                                             
}                        


kernel void color(global int* image)
{
     image[get_global_id(0) * 3] = 0;
     image[get_global_id(0) * 3 + 1] = 0;
     image[get_global_id(0) * 3 + 2] = 50;
}