[Jrman-commit] drafts/src/org/jrman/shaders LightShadowspotlight.java,NONE,1.1

[<ma...@us...>]

Update of /cvsroot/jrman/drafts/src/org/jrman/shaders
In directory sc8-pr-cvs1:/tmp/cvs-serv20980/src/org/jrman/shaders

Added Files:
	LightShadowspotlight.java 
Log Message:
Implemented shadowspotlight
Added random number generator

--- NEW FILE: LightShadowspotlight.java ---
/*
 LightShadowspotlight.java
 Copyright (C) 2003 Gerardo Horvilleur Martinez

 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 as published by the Free Software Foundation; either version 2
 of the License, or (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

package org.jrman.shaders;

import javax.vecmath.Color3f;
import javax.vecmath.Point3f;
import javax.vecmath.Vector3f;

import org.jrman.attributes.Space;
import org.jrman.geom.Transform;
import org.jrman.grid.Color3fGrid;
import org.jrman.grid.FloatGrid;
import org.jrman.grid.Point3fGrid;
import org.jrman.grid.Vector3fGrid;
import org.jrman.parser.Declaration;
import org.jrman.parser.Global;
import org.jrman.parser.Parameter;
import org.jrman.render.ShaderVariables;

public class LightShadowspotlight extends LightShader {

    static FloatGrid fg1 = new FloatGrid();

    static FloatGrid fg2 = new FloatGrid();

    static FloatGrid fg3 = new FloatGrid();
    
    static Color3fGrid cg1 = new Color3fGrid();

    private static Vector3f vtmp = new Vector3f();

    private static Point3f from = new Point3f();

    private static Point3f to = new Point3f();

    static Color3f c1 = new Color3f();

    static Point3fGrid pg = new Point3fGrid();
    
    static FloatGrid fg = new FloatGrid();
    
    static Color3fGrid cg = new Color3fGrid();

    protected void initDefaults() {
        float[][] intensity = new float[1][];
        intensity[0] = new float[1];
        intensity[0][0] = 1f;
        Parameter param =
            new Parameter(new Declaration("intensity", "uniform float"), intensity);
        defaultParameters.put("intensity", param);
        Color3f[][] lightcolor = new Color3f[1][];
        lightcolor[0] = new Color3f[1];
        lightcolor[0][0] = new Color3f(1f, 1f, 1f);
        param = new Parameter(new Declaration("lightcolor", "uniform color"), lightcolor);
        defaultParameters.put("lightcolor", param);
        Point3f[][] from = new Point3f[1][];
        from[0] = new Point3f[1];
        from[0][0] = new Point3f(0f, 0f, 0f);
        param = new Parameter(new Declaration("from", "uniform point"), from);
        defaultParameters.put("from", param);
        Point3f[][] to = new Point3f[1][];
        to[0] = new Point3f[1];
        to[0][0] = new Point3f(0f, 0f, 1f);
        param = new Parameter(new Declaration("to", "uniform point"), to);
        defaultParameters.put("to", param);
        float[][] coneangle = new float[1][];
        coneangle[0] = new float[1];
        coneangle[0][0] = (float) Math.toRadians(30);
        param = new Parameter(new Declaration("coneangle", "uniform float"), coneangle);
        defaultParameters.put("coneangle", param);
        float[][] conedeltaangle = new float[1][];
        conedeltaangle[0] = new float[1];
        conedeltaangle[0][0] = (float) Math.toRadians(5);
        param =
            new Parameter(new Declaration("conedeltaangle", "uniform float"), conedeltaangle);
        defaultParameters.put("conedeltaangle", param);
        float[][] beamdistribution = new float[1][];
        beamdistribution[0] = new float[1];
        beamdistribution[0][0] = 2f;
        param =
            new Parameter(
                new Declaration("beamdistribution", "uniform float"),
                beamdistribution);
        defaultParameters.put("beamdistribution", param);
        float[][] bias = new float[1][];
        bias[0] = new float[1];
        bias[0][0] = .1f;
        param = new Parameter(new Declaration("bias", "uniform float"), bias);
        defaultParameters.put("bias", param);
        String[][] shadowmap = new String[1][];
        shadowmap[0] = new String[1];
        shadowmap[0][0] = "";
        param =
            new Parameter(new Declaration("shadowmap", "string"), shadowmap);
        defaultParameters.put("shadowmap", param);
        float[][] samples = new float[1][];
        samples[0] = new float[1];
        samples[0][0] = 16f;
        param = new Parameter(new Declaration("samples", "uniform float"), samples);
        defaultParameters.put("samples", param);
        float[][] blur = new float[1][];
        blur[0] = new float[1];
        blur[0][0] = 0f;
        param = new Parameter(new Declaration("blur", "uniform float"), blur);
        defaultParameters.put("blur", param);
    }

    public boolean shade(
        final ShaderVariables sv,
        Point3fGrid P,
        Vector3fGrid N,
        float angle) {
        super.shade(sv, P, N, angle);
        Parameter param = (Parameter) getParameter(sv, "intensity");
        float[][] f = (float[][]) param.getData();
        final float intensity = f[0][0];
        param = (Parameter) getParameter(sv, "lightcolor");
        Color3f[][] c = (Color3f[][]) param.getData();
        final Color3f lightColor = c[0][0];
        Transform shaderTransform = attributes.getTransform();
        if (attributes.getSpace() == Space.WORLD)
            shaderTransform = Global.getTransform("camera").concat(shaderTransform);
        param = (Parameter) getParameter(sv, "from");
        Point3f[][] p = (Point3f[][]) param.getData();
        shaderTransform.transformPoint(p[0][0], from);
        param = (Parameter) getParameter(sv, "to");
        p = (Point3f[][]) param.getData();
        shaderTransform.transformPoint(p[0][0], to);
        param = (Parameter) getParameter(sv, "coneangle");
        f = (float[][]) param.getData();
        final float coneangle = f[0][0];
        param = (Parameter) getParameter(sv, "conedeltaangle");
        f = (float[][]) param.getData();
        final float conedeltaangle = f[0][0];
        param = (Parameter) getParameter(sv, "beamdistribution");
        f = (float[][]) param.getData();
        final float beamdistribution = f[0][0];
        param = (Parameter) getParameter(sv, "bias");
        f = (float[][]) param.getData();
        final float bias = f[0][0];
        param = (Parameter) getParameter(sv, "shadowmap");
        String[][] s = (String[][]) param.getData();
        final String shadowmap = s[0][0];
        param = (Parameter) getParameter(sv, "samples");
        f = (float[][]) param.getData();
        final float samples = f[0][0];
        param = (Parameter) getParameter(sv, "blur");
        f = (float[][]) param.getData();
        final float blur = f[0][0];
        vtmp.sub(to, from);
        final Vector3f A = vtmp;
        A.normalize();
        return illuminate(sv, P, N, angle, from, A, coneangle, new Statement() {
            public void execute(ShaderVariables sv) {
                fg1.dot(sv.L, A);
                fg2.length(sv.L);
                fg1.div(fg1, fg2);
                FloatGrid cosangle = fg1;
                fg2.dot(sv.L, sv.L);
                fg3.pow(cosangle, beamdistribution);
                fg3.div(fg3, fg2);
                FloatGrid atten = fg3;
                fg2.smoothstep(
                    (float) Math.cos(coneangle),
                    (float) Math.cos(coneangle - conedeltaangle),
                    cosangle);
                atten.mul(atten, fg2);
                fg2.mul(atten, intensity);
                cg1.set(fg2);
                sv.Cl.set(lightColor, tmpCond1);
                sv.Cl.mul(sv.Cl, cg1, tmpCond1);
                if (!shadowmap.equals("")) {
                   pg.transform(sv.P, sv.cameraToWorld);
                   fg.shadow(shadowmap, pg, bias, samples, blur);
                   fg.sub(1f, fg);
                   cg.set(fg);
                   sv.Cl.mul(sv.Cl, cg);
               }
           }
        });
    }
}