/home/carolina/workspace/spvolren_cpu/volumeShaders/isosurface_scattering_sm3.fp

Vá para a documentação deste arquivo.

!!ARBfp1.0
OPTION NV_fragment_program2;

# Copyright (c) 2005  Institute for Visualization and Interactive
# Systems, University of Stuttgart, Germany
#
# This source code is distributed as part of the single-pass volume
# rendering project. Details about this project can be found on the
# project web page at http://www.vis.uni-stuttgart.de/eng/research/
# fields/current/spvolren. This file may be distributed, modified,
# and used free of charge as long as this copyright notice is
# included in its original form. Commercial use is strictly
# prohibited.
#
# Filename: isosurface_scattering_sm3.fp

#! VOLUME = 0
#! TRANSFERFUNCTION = 1
#! BACKGROUND = 2
#! SCATTERING = 3

# r = step
# g = gradient scale
# b = gradient offset
# a = z-value of background plane
PARAM params = program.local[0];

# r = texture coordinate scale
# g = number of iterations
# b = isovalue of isosurface
# a = soft shadow scale
PARAM params2 = program.local[1];
PARAM center = program.local[2];
PARAM texMax = program.local[3];

# r = scattering scale factor
PARAM params3 = program.local[4];

PARAM scaleFactors = program.local[5];

TEMP geomDir;
TEMP geomPos;
TEMP criterion;
TEMP specular;
TEMP lightVec;
TEMP texCoord;
TEMP enterPos;
TEMP ambient;
TEMP diffuse;
TEMP prevPos;
TEMP texblen;
TEMP diffVec;
TEMP halfway;
TEMP scatter;
TEMP eyeVec;
TEMP intens;
TEMP camera;
TEMP normal;
TEMP weight;
TEMP scale;
TEMP temp1;
TEMP temp2;
TEMP temp;
TEMP grad;
TEMP sign;
TEMP pos;
TEMP src;
TEMP dst;
TEMP dir;
TEMP tex;
TEMP tempr;
TEMP scalAct;
TEMP scalPre;

# Compute the ray's starting point
MOV geomPos, fragment.texcoord[0];
MUL pos, geomPos, scaleFactors;
MOV pos.a, 0.0;

# Compute the camera position by translating the origin to the center of the
# volume
MOV camera, state.matrix.modelview.invtrans.row[3];

# Compute the ray direction
SUB geomDir, geomPos, camera;

# Normalize the direction
DP3 geomDir.w, geomDir, geomDir;
RSQ geomDir.w, geomDir.w;
MUL geomDir, geomDir, geomDir.w;
MOV geomDir.w, 0.0;

MUL dir, geomDir, scaleFactors;

# Initialize texture corrdinates
# texcood.a inherits level of detail
MOV texCoord, 0.0;
MOV pos.w, 0.0;

# Initialize the 'previous' intensity
TXL intens, pos, texture[0], 3D;
MOV intens.g, intens.a;

# Initialize destination color
MOV dst, 0.0;
REP params2.g;
        REP params2.g;
                # Lookup scalar and gradient
                TXL tex, pos, texture[0], 3D;

                # Component 'b' written to circumvent driver bug
                MOV intens.r, tex.a;

                # Move one step forward
                MAD pos.xyz, dir, params.r, pos;

                # Isosurface if differences with past and present
                # scalar values and isovalue have different signs 
                SUB temp.rg, intens, params2.b;
                MULC temp.x, temp.r, temp.g;
                IF LE.x;
                        # Isosurface found

                        # Determine if subsurface scattering refers to scalar
                        # values below or above the isovalue (1 = greater, 0 = smaller)
                        SGT criterion, intens.r, intens.g;

                        # Get scalar value from actual position
                        MAD pos, -dir, params.r, pos;
                        TXL scalAct, pos, texture[0], 3D;

                        # Get scalar value from previous position
                        MAD prevPos, -dir, params.r, pos;
                        TXL scalPre, prevPos, texture[0], 3D;

                        SUB temp.r, params2.b, scalPre.a;
                        SUB temp.g, scalAct.a, scalPre.a;

                        # Perform linear interpolation to increase accuracy
                        DIV_SAT temp.b, temp.r, temp.g;
                        LRP pos, temp.b, pos, prevPos;

                        # Look up the color based on the isovalue
                        MOV texCoord.rgb, params2.b;
                        TXL src, texCoord, texture[1], 2D;

                        # We assume that isosurfaces are opaque
                        MOV src.a, 1.0;
                        # 'Normalize' color
                        NRM src, src;

                        # isosurface hit found
                        MOV dst.a, 1.0;

                        # Everything is done, jump out of loop
                        BRK;
                ENDIF;

                MOV intens.g, intens.r;

                # Set values to zero if outside volume
                SGE temp1, pos, 0.0;
                SLE temp2, pos, texMax;
                DP3 weight.r, temp1, temp2;
                SEQC weight.r, weight.r, 3.0;

                # Already outside volume, skip the rest
                BRK (EQ.x);

        ENDREP;

        # Already outside volume, skip the rest
        BRK (EQ.x);
        # isosurface hit?
        MOVC temp, dst.a;
        BRK (GT.x);

ENDREP;

# -------------- Scattering Code Begin -----------------------

MOV scatter, 0.0;

# Only need to compute scattering if isosurface was hit
MOVC dst.a, dst.a;
IF NE.w;

        SUB lightVec.rgb, state.light[0].position, pos;
        MOV lightVec.a, 0.0;
        NRM lightVec, lightVec;

        # Determine gradient at corrected position (same as above)
        TXL grad.rgb, pos, texture[0], 3D;

        # Determine scale factor for gradient
        SNE temp.rgb, grad, 0.0;
        DP3_SAT temp.r, temp, 1.0;

        # Reconstruct the gradient
        MAD_SSAT grad.rgb, tex, 2.0, -1.0;
        NRM_SSAT grad.rgb, grad;

        # Set gradient to zero if it was zero
        MUL grad.rgb, grad, temp.r;

        # Re-orient the gradient to get a
        # correct surface normal
        MOV temp, 0.0;
        DP3 temp.r, -geomDir, grad;
        NRM temp, temp;
        MUL grad.rgb, grad, temp.r;
        NRM grad.rgb, grad;
        
        DP3C_SAT temp.r, grad, lightVec;
        MOV tempr, temp.r;
        
        # compute diffuse lighting 
        #Perform the lighting calculation (yes, we know LIT!)

        # Ambient term
        MUL ambient, state.light[0].ambient, src;

        # Diffuse term
        TEX diffuse, {0.2, 0.0, 0.0, 0.0}, texture[3], 1D;
        # Specular term
        
        # Isosurfaces are opaque
        ADD dst.rgb, diffuse, ambient;
        MUL_SAT dst.rgb, dst, temp.r;

        # Make sure the isosurface is not intersected twice
        # in the same location
        MAD pos.xyz, dir, params.r, pos;

        REP params2.g; 
                REP params2.g; 
                        # Move one step forward
                        MAD pos.xyz, lightVec, params.r, pos;

                        # Exit loop when leaving volume
                        SGE temp1, pos, 0.0;
                        SLE temp2, pos, texMax;
                        DP3 weight.r, temp1, temp2;
                        SEQC weight.r, weight.r, 3.0;
                        BRK (EQ.x);

                        # Determine scalar value
                        TXL tex, pos, texture[0], 3D;

                        # Component 'b' written to circumvent driver bug
                        MOV intens.r, tex.a;

                        # Adjust scatter value
                        SUBC temp.x, intens.r, params2.b;
                        IF LE.x;
                                # Intensity smaller isovalue
                                MOVC temp.x, criterion.x;
                                IF EQ.x;
                                        # Want to sum up intensities less than isovalues
                                        MOV scale, params3.r;
                                        SUB temp.rg, intens, params2.b;
                                        MULC temp, temp.r, temp.g;
                                        IF LE.x;
                                                # Sign change
                                                SUB temp.r, params2.b, intens.r;
                                                SUB temp.g, intens.g, intens.r;
                                                DIV_SAT temp.b, temp.r, temp.g;
                                                MUL scale, scale, temp.b;
                                        ENDIF;
                                        MAD scatter.x, params.r, scale, scatter.x;
                                ENDIF;
                        ELSE;
                                #  Scalar greater isovalue
                                MOVC temp.x, criterion.x;
                                IF GT.x;
                                        # Want to sum up intensities greater than isovalues
                                        MOV scale, params3.r;
                                        SUB temp.rg, intens, params2.b;
                                        MULC temp, temp.r, temp.g;
                                        IF LE.x;
                                                # Sign change
                                                SUB temp.r, intens.r, params2.b;
                                                SUB temp.g, intens.r, intens.g;
                                                DIV_SAT temp.b, temp.r, temp.g;
                                                MUL scale, scale, temp.b;
                                        ENDIF;
                                        MAD scatter.x, params.r, scale, scatter.x;
                                ENDIF;
                        ENDIF;

                        MOV intens.g, intens.r;
                ENDREP;
                
                # Already outside volume, skip the rest
                BRK (EQ.x);
        ENDREP;
                        
        TXL temp.rgb, scatter.x, texture[3], 1D;
        #ADD dst.xyz, dst, temp;
                        
        LRP dst.rgb, tempr, dst, temp; 
ENDIF; # isosurface hit

# -------------- Scattering Code End -------------------------

# Compute the normal of the background plane (this is just the negative view
# direction which initially is (0, 0, -1))
MOV normal, state.matrix.modelview.row[2];

# Compute the plane constant (we want the plane to be located in the volume
# center)
DP3 temp1.r, normal, center;

# Move the plane behind the volume: d' = <n,(x - l n)> = <n, x> - l <n, n>;
# l = 0.71 is chosen since it is greater than half the cube diagonal 
DP3 temp1.g, normal, normal;
MAD temp1.r, temp1.g, -.71, temp1.r;

# Compute ray parameter
DP3 temp1.g, normal, geomPos;
SUB temp1.g, temp1.r, temp1.g;
DP3 temp1.b, normal, geomDir;
DIV temp.r, temp1.g, temp1.b;

# Compute ray/plane intersection
MAD temp.rgb, temp.r, geomDir, geomPos;

# Compute the difference vector
SUB diffVec, temp, center;

# Compute the texture coordinates
DP3 temp.r, diffVec, state.matrix.modelview.row[0];
DP3 temp.g, diffVec, state.matrix.modelview.row[1];
MUL temp.rg, temp, params2.r;

# Center background image
ADD temp.rg, temp, .5;

# Look up the texel value
TEX temp.rgb, temp, texture[2], 2D;
MOV temp.a, 1.0;

# Blend the background pixel
SUB texblen, 1.0, dst.a;
MAD dst, temp, texblen.x, dst;

# Write the output color
MOV result.color, dst;

END

---