Slick2d jak zrobić oświetlenie

[AdirasOwns]

Witam, mógłby mi ktoś wytłumaczyć w jaki sposób za pomocą slick2d mogę zrobić system oświetlenia podobny do tego:

 

 

https://www.youtube.com/watch?v=slz76M59kOE

 

 

Wydaje mi się że taki efekt można uzyskać dzięki funkcji setDrawMode() jednak nie mogłem znaleźć nic przydatnego na ten temat.

[Gość]

 
Um on ma tam cos takiego ^ i pewnie rysuje to używając najzwyczajniej glBlendFunc GL11.GL_ZERO  GL11.GL_SRC_COLOR. A kolorki zmienia po prostu zmieniajac kolor (glColor4f etc).
Można to też zrobić shaderem praktycznie w ten sam sposób.
 
Shader by wyglądał następująco:
 
Fragment:

varying vec2 pos;

struct Light
{
    vec4 color;
    vec3 attenuation;
    float intensity;
};

uniform Light light;


void main() {
    float d = sqrt(dot(pos, pos)) / 2.0;
    float att = 1.0 / ( light.attenuation.x + (light.attenuation.y*d) + (light.attenuation.z*d*d) );

    att = (att - 0.15) / (1.0 - 0.15);
    vec3 result = (light.color.rgb) * att;
    gl_FragColor = vec4( result, light.intensity);
}

Vertex:

varying vec2 pos;

void main()
{
    pos = gl_Vertex.xy;
    gl_Position = gl_ModelViewProjectionMatrix * vec4(gl_Vertex.xy, 0.0, 1.0);
}

Program:

public class LightShader extends ShaderProgram {
    
    public LightShader(String vertFile, String fragFile) throws SlickException{
        super(readFile(vertFile), readFile(fragFile));
    }
    
    public void setUniformLight(String name, Light light){
                setUniform4f(name + ".color", light.tint);
                setUniform3f(name + ".attenuation", light.attenuation[0], light.attenuation[1], light.attenuation[2]);
                setUniform1f(name + ".intensity", light.intensity);
    }
    
    public void setUniformLightArray(String name, List<Light> lights){
            for(Light light: lights){
                setUniform2f(name + "[" + lights.indexOf(light) + "].pos", light.screenX(), light.screenY());
                setUniform4f(name + "[" + lights.indexOf(light) + "].color", light.tint);
                setUniform3f(name + "[" + lights.indexOf(light) + "].attenuation", light.attenuation[0], light.attenuation[1], light.attenuation[2]);
                setUniform1f(name + "[" + lights.indexOf(light) + "].intensity", light.intensity);
                setUniform1f(name + "[" + lights.indexOf(light) + "].scale", light.scale);
            }
    }
    
}

Light:

public class Light {
    
    protected SGL GL = Renderer.get();

    protected final Image lightSprite;
    
    public static LightShader program = null;
    static {
        try {
            program = new LightShader("engine/lightV.glsl", "engine/lightF.glsl");
        } catch (SlickException ex) {
            Logger.getLogger(Light.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
    /**
* The position of the light
*/
    public float x, y;
    /**
* The RGB tint of the light, alpha is ignored
*/
    public Color tint;
    /**
* The alpha value of the light, default 1.0 (100%)
*/
    public float intensity;
    /**
* The amount to scale the light (use 1.0 for default size).
*/
    public float scale;
    public final float scaleOrig;
    public final float[] attenuation = new float[]{0.4f, 3.0f, 20.0f};
    //original scale

    public Light(float x, float y, float scale, float intensity, Color tint) {
        lightSprite = GameCache.res("lighting_sprites.png");
        this.x = x;
        this.y = y;
        this.scale = scale;
        this.scaleOrig = scale;
        this.intensity = intensity;
        this.tint = tint;
    }
    
    public Light(float x, float y, float scale, float intensity, String image, Color tint) {
        this.lightSprite = GameCache.res(image+".png");
        this.x = x;
        this.y = y;
        this.scale = scale;
        this.scaleOrig = scale;
        this.intensity = intensity;
        this.tint = tint;
    }

    public Light(float x, float y, float scale) {
        this(x, y, scale, 1f, Color.white);
    }

    public void render(Graphics g) {
        
        g.setDrawMode(Graphics.MODE_ADD);
        program.bind();
        
        program.setUniformLight("light", this);
        
        GL.glPushMatrix();
        GL.glTranslatef(screenX(), 720-screenY(), 0);
        float radius = MathHelper.scaleRange(scale, 1f, 2f, 128, 256);
        GL.glScalef(radius, radius, 0f);
        GL.glBegin(SGL.GL_QUADS);
        GL.glVertex3f(-1.0f, -1.0f, 0.0f);
        GL.glVertex3f(1.0f, -1.0f, 0.0f);
        GL.glVertex3f(1.0f, 1.0f, 0.0f);
        GL.glVertex3f(-1.0f, 1.0f, 0.0f);
        GL.glEnd();
        GL.glPopMatrix();
        
        LightShader.unbind();
        g.setDrawMode(Graphics.MODE_NORMAL);
    }
    
    public void update(long elapsed){
        scale = scaleOrig + MathHelper.scaleRange((float)Math.sin(elapsed /1000f), -1.0f, 1.0f, 1f/4f, 4f);
    }

    public float screenX() {
        return x - Camera.viewPort.getX();
    }

    public float screenY() {
        return y - Camera.viewPort.getY();
    }

    public boolean isVisible(Camera c) {
        return x > c.viewPort.getX() - 1024 && y > c.viewPort.getY() - 1024
                && x < c.viewPort.getX() + c.viewPort.getWidth() + 1024
                && y < c.viewPort.getY() + c.viewPort.getHeight() + 1024;
    }
}

@Edit przeca w komentach ktoś już posłał src : http://pastebin.com/0VHkJEhY

[AdirasOwns]

Okej dzięki, a jest jakiś sposób na zrobienie tego na samym slicku bez używania OpenGL?

[Gość]

Okej dzięki, a jest jakiś sposób na zrobienie tego na samym slicku bez używania OpenGL?

 

A jest jakiś sposób na zrobienie bułki z masłem bez używania bułki?

[AdirasOwns]

A jest jakiś sposób na zrobienie bułki z masłem bez używania bułki?

Na to pytanie odpowiedzi udzieli Ci jedynie student.

 

Chodzi mi o to, że przecież metody rysujące z klasy Graphics nie wykorzystują GL'a prawda? Na razie szukam sposobu który nie będzie wymagał znajomości OpenGL.

[Gość]

Na to pytanie odpowiedzi udzieli Ci jedynie student.

 

Chodzi mi o to, że przecież metody rysujące z klasy Graphics nie wykorzystują GL'a prawda? Na razie szukam sposobu który nie będzie wymagał znajomości OpenGL.

Nawet bułka z chlebem potrzebuje bułki by zaistnieć.

 

Jak nie ;o Tam jest wszędzie opengl. To jest tylko rozszeżenie lwjgl-a