Vary amount of transparency: material or shaderParm howto..?

[nbohr1more]

Interesting. The interaction shaders have a specific vertex.color attribute.

 

I am suspecting that your shader should be

 
!!ARBvp1.0
OPTION ARB_position_invariant;

MOV vertex.color, {0.5, 0.5, 0.5, 1.0};

END
 

instead.

 

But I still think that this operation must be done at the vertex stage just before:

 
MAD        result.color, vertex.color, program.env[16], program.env[17];
 

in a full light interaction called from the material (how Prey does it).

 

Now that I've bruised my brains on this, time to make the glprog and material def.

[nbohr1more]

Here's the material syntax:

 
translucent/example

{



    // one set comprised of a normal map and diffuse map utilizing the vertexcolor keyword



    {

        blend add

        program    translucent_hack.vfp

        vertexParm        0        1, 1, 1, 1        // UV Scales for Diffuse and Bump

        vertexParm        1        1, 1, 1, 1    // (X,Y) UV Scale for specular

        vertexParm        2        global2, global3, global4, 1



        fragmentMap        0        cubeMap env/gen1

        fragmentMap        1        normalmap.tga

        fragmentMap        2        diffusemap.tga

        fragmentMap        3        specularmap.tga

        vertexcolor

    }



    // a second set using the same images with the inversevertexcolor keyword



    // the scale function here is "inverting" the normal map so that it catches light from the opposite side.



    {

        blend add

        program    translucent_hack.vfp

        vertexParm        0        1, 1, 1, 1        // UV Scales for Diffuse and Bump

        vertexParm        1        1, 1, 1, 1    // (X,Y) UV Scale for specular

        vertexParm        2        global2, global3, global4, 1



        fragmentMap        0        cubeMap env/gen1

        fragmentMap        1        scale(normalmap.tga, 1, 1, 0, 1)

        fragmentMap        2        diffusemap.tga

        fragmentMap        3        specularmap.tga

        inversevertexcolor

    }
 
}

and I've attached the VFP.

 

 

What this should do is an additive blend of an entire light interaction operation which is equivalent to what the engine does on a whole but we are now only doing it for this material type. What I didn't get a chance to sort out is whether the vertex parms from our old enhanced ambient would be appropriate here.

 

I didn't have time to test.

[Obsttorte]

Maybe you have to pass the vertex color to the fragment color in a fragment program as well?!

[Bikerdude]

What this should do is an additive blend of an entire light interaction operation which is equivalent to what the engine does on a whole but we are now only doing it for this material type. What I didn't get a chance to sort out is whether the vertex parms from our old enhanced ambient would be appropriate here.

 

I didn't have time to test.translucent_hack.vfp.txt

I assume I just dump this file in the glprogs folder, how do I then point to it in a material def..?

[nbohr1more]

Yes, that goes into glprogs. (needs to be renamed without the *.txt extension).

 

The example material def I posted above will already find it there. ( "program translucent_hack.vfp")

[Bikerdude]

So using that I have the following -

translucent/wallpaper_fancy_red
{

    // one set comprised of a normal map and diffuse map utilizing the vertexcolor keyword

    {
        blend    	textures/darkmod/paint_paper/wallpaper_fancy_red
        map    	 	textures/darkmod/paint_paper/wallpaper_fancy_red
        vertexcolor
    }
    {
        blend    	textures/darkmod/paint_paper/wallpaper_fancy_r
        map    		textures/darkmod/paint_paper/wallpaper_fancy_r
        vertexcolor
    }

    // a second set using the same images with the inversevertexcolor keyword

    // the scale function here is "inverting" the normal map so that it catches light from the opposite side.

    {
        blend    	textures/darkmod/paint_paper/wallpaper_fancy_local
        map    		scale(normalmap.tga, 1, 1, 0, 1)
        inversevertexcolor
    }
    {
        blend    	textures/darkmod/paint_paper/wallpaper_fancy_r
        map    		textures/darkmod/paint_paper/wallpaper_fancy_r
        inversevertexcolor
}

[nbohr1more]

Here is a fixed version:

 

 

 
translucent/wallpaper_fancy_red
{

   {
    // one set comprised of a normal map and diffuse map utilizing the vertexcolor keyword
    
    blend add

        program    translucent_hack.vfp  // program that forces vertex color to grey and runs the lighting stages

        vertexParm        0        1, 1, 1, 1        // UV Scales for Diffuse and Bump

        vertexParm        1        1, 1, 1, 1    // (X,Y) UV Scale for specular

        vertexParm        2        global2, global3, global4, 1



        fragmentMap        0        cubeMap env/gen1

        fragmentMap        1        textures/darkmod/paint_paper/wallpaper_fancy_local

        fragmentMap        2        textures/darkmod/paint_paper/wallpaper_fancy_red

        fragmentMap        3        _black // specular

        vertexcolor

    }
   
    {
    
       
    // a second set using the same images with the inversevertexcolor keyword
    // the scale function here is "inverting" the normal map so that it catches light from the opposite side.

        blend add

        program    translucent_hack.vfp    // program that forces vertex color to gray and runs the lighting stages

        vertexParm        0        1, 1, 1, 1        // UV Scales for Diffuse and Bump

        vertexParm        1        1, 1, 1, 1    // (X,Y) UV Scale for specular

        vertexParm        2        global2, global3, global4, 1



        fragmentMap        0        cubeMap env/gen1

        fragmentMap        1        scale(textures/darkmod/paint_paper/wallpaper_fancy_local, 1, 1, 0, 1)

        fragmentMap        2        textures/darkmod/paint_paper/wallpaper_fancy_red

        fragmentMap        3        _black // specular

        inversevertexcolor

    }

}
 

[Bikerdude]

ta.

[nbohr1more]

Hmm.

 

I think:

 
fragmentMap 2
 
fragmentMap 3
 

needs to be

 
fragmentMap 4  texture // diffuse
 
fragmentMap 5 texture // specular
 

I guess Biker might let me know before I get a chance to test tonight. ?

[Bikerdude]

testing it now...

 

So as follows.?

translucent/wallpaper_fancy_red
{
   {
    // one set comprised of a normal map and diffuse map utilizing the vertexcolor keyword
    
    blend add

        program    translucent_hack.vfp  // program that forces vertex color to grey and runs the lighting stages

        vertexParm        0        1, 1, 1, 1        // UV Scales for Diffuse and Bump
        vertexParm        1        1, 1, 1, 1    // (X,Y) UV Scale for specular
        vertexParm        2        global2, global3, global4, 1

        fragmentMap        0        cubeMap env/gen1
        fragmentMap        1        textures/darkmod/paint_paper/wallpaper_fancy_local
        fragmentMap        4		textures/darkmod/paint_paper/wallpaper_fancy_red
        fragmentMap        5        _black // specular

        vertexcolor
    }
 
    {       
    // a second set using the same images with the inversevertexcolor keyword
    // the scale function here is "inverting" the normal map so that it catches light from the opposite side.

        blend add

        program    translucent_hack.vfp    // program that forces vertex color to gray and runs the lighting stages

        vertexParm        0        1, 1, 1, 1        // UV Scales for Diffuse and Bump
        vertexParm        1        1, 1, 1, 1    // (X,Y) UV Scale for specular
        vertexParm        2        global2, global3, global4, 1

        fragmentMap        0        cubeMap env/gen1
        fragmentMap        1        scale(textures/darkmod/paint_paper/wallpaper_fancy_local, 1, 1, 0, 1)
        fragmentMap        4        textures/darkmod/paint_paper/wallpaper_fancy_red
        fragmentMap        5       _black // specular

        inversevertexcolor
    }
}

[nbohr1more]

Yeah. If the fragmentMap values match the texture number order in the VFP then that should be the correct way.

[Bikerdude]

Tested and the texture is just black in-game.

[nbohr1more]

The last thing I can think of is to add fragmentMap values for the light projection and falloff textures.

 

Eg:

 
fragmentMap 2 _noFallOff  // falloff texture
 
fragmementMap 3 textures/lights/brightround // projection texture
 

This would be a little odd because it would mean that no mater what light shader you use, this material

will act like a specific light projection is hitting it. Might not be too bad but it would definitely mismatch things

like the window projections.

 

I presume you tried both 2/3 and 4/5 mappings with the same results?

[Bikerdude]

nope, only 4/5 will revert to 2/3 and see what happens and then the above if that fails.

[nbohr1more]

I had another thought.

 

Perhaps adding a black diffuse stage above the program stage would force the engine to include the surface in vertex cache.

 

{

{

Diffusemap _black

}

{

Blend add

Program translucent_hack.vfp

Etc

}

VertexColor

}

Oh, and the material will need the "twosided" keyword.

[nbohr1more]

Complete example if someone wants to try before I do:

 

 

 
translucent/wallpaper_fancy_red
{
twosided


  {
    // one set comprised of a normal map and diffuse map utilizing the vertexcolor keyword
    
    {
    
    diffusemap _black // force lighting pass into vertex cache
    
    }
    
    {
    
    blend add

        program    translucent_hack.vfp  // program that forces vertex color to grey and runs the lighting stages

        vertexParm        0        1, 1, 1, 1        // UV Scales for Diffuse and Bump

        vertexParm        1        1, 1, 1, 1    // (X,Y) UV Scale for specular

        vertexParm        2        global2, global3, global4, 1



        fragmentMap        0        cubeMap env/gen1

        fragmentMap        1        textures/darkmod/paint_paper/wallpaper_fancy_local

        fragmentMap        2        textures/darkmod/paint_paper/wallpaper_fancy_red

        fragmentMap        3        _black // specular


    }
      vertexcolor
      
  }  
  {
          
       
    // a second set using the same images with the inversevertexcolor keyword
    // the scale function here is "inverting" the normal map so that it catches light from the opposite side.
    
    {
    
    diffusemap _black
    
    }
    {
        blend add

        program    translucent_hack.vfp    // program that forces vertex color to gray and runs the lighting stages

        vertexParm        0        1, 1, 1, 1        // UV Scales for Diffuse and Bump

        vertexParm        1        1, 1, 1, 1    // (X,Y) UV Scale for specular

        vertexParm        2        global2, global3, global4, 1



        fragmentMap        0        cubeMap env/gen1

        fragmentMap        1        scale(textures/darkmod/paint_paper/wallpaper_fancy_local, 1, 1, 0, 1)

        fragmentMap        2        textures/darkmod/paint_paper/wallpaper_fancy_red

        fragmentMap        3        _black // specular

     

    }
   inversevertexcolor
   }
}
 

[Bikerdude]

will try this evening, ta.

[nbohr1more]

I can say that this doesn't work but I've made progress this evening.

 

As I suspected, fragmentMap 4 and 5 map to diffuse and specular whilst 2 and 3 map to falloff and projection images. The problem being, how do we acquire the images from the light rather than hard code them here. If there were a _currentLight internal image that would be great but I suspect that this is not the case.

 

I'll try to resume this on Monday. I've got family stuff all weekend.

[AluminumHaste]

Would you be able to do what I did for the stained glass texture and use the Bumpmap stage? Which I know makes no sense but hey, it worked for the stained glass windows.

[nbohr1more]

I didn't get any changes tested last night but I've finally wrapped my head around the VertexParm mappings.

 

VertexParm <number> == program.local[<number>]

 

global<number> == program.env[<number>]

 

I am still at a dead end about the light projection images unless FragmentParm can somehow grab them.

 

After decoding all this I am wondering if I can just plug a program.local[x] reference into the default interaction.vfp

in place of the vertex color attribute and then call it via VertexParm in the material def.

 

eg.

 

end of vp:

 
MOV vertex.color, program.local[0];
MAD        result.color, vertex.color, program.env[16], program.env[17];
 

and then

 

(inside the material def)

 
VertexParm   0       0.5, 0.5, 0.5, 1.0
 

I think this is how the RGB keywords (etc)

work so it should be possible to do it this way AFAIK. I don't recall seeing anything in the material parser that requires

VertexParm to be after a Program reference in the material def.

[Bikerdude]

Evening

 

I too also haven't testing anything yet, will try and do it this evening....

[nbohr1more]

Well, with the added MOV statement in the ARB (vfp) it won't work, but you can evaluate the strangeness of the current example

if you comment that line out with a # symbol in translucent_hack.vfp and use this material:

 
translucent/wallpaper_fancy_red
{
twosided


    // one set comprised of a normal map and diffuse map utilizing the vertexcolor keyword
    
    {
    
    diffusemap _black // force lighting pass into vertex cache
    vertexcolor
    }
    
    {
    
    blend add

        program    translucent_hack.vfp  // program that forces vertex color to grey and runs the lighting stages

        vertexParm        0        1, 1, 1, 1        // UV Scales for Diffuse and Bump

        vertexParm        1        1, 1, 1, 1    // (X,Y) UV Scale for specular

        vertexParm        2        global2, global3, global4, 1



        fragmentMap        0        cubeMap env/gen1
 
        fragmentMap        1        textures/darkmod/paint_paper/wallpaper_fancy_local
 
        framentMap          2        _noFalloff
 
        fragmentMap        3        textures/lights/brightround

        fragmentMap        4        textures/darkmod/paint_paper/wallpaper_fancy_red

        fragmentMap        5        _black // specular

     vertexcolor
    }
     
      
  
  
          
       
    // a second set using the same images with the inversevertexcolor keyword
    // the scale function here is "inverting" the normal map so that it catches light from the opposite side.
    
    {
    
    diffusemap _black
    inversevertexcolor
    }
    
    {
        blend add

        program    translucent_hack.vfp    // program that forces vertex color to gray and runs the lighting stages

        vertexParm        0        1, 1, 1, 1        // UV Scales for Diffuse and Bump

        vertexParm        1        1, 1, 1, 1    // (X,Y) UV Scale for specular

        vertexParm        2        global2, global3, global4, 1



        fragmentMap        0        cubeMap env/gen1

        fragmentMap        1        scale(textures/darkmod/paint_paper/wallpaper_fancy_local, 1, 1, 0, 1)
 
        framentMap          2       _noFalloff
 
        fragmentMap        3        textures/lights/brightround 

        fragmentMap        4        textures/darkmod/paint_paper/wallpaper_fancy_red

        fragmentMap        5        _black // specular

     
        inversevertexcolor 
    }
   

}
 

[Bikerdude]

The heat is just wiping me out, its nearly 31c in the flat atm. So will have a look in the morning.

[rich_is_bored]

The indirect nature of this workaround seems to cause more problems than it solves. I think this and vertex colors are a dead end.

 

Instead of trying to control the contribution of each render pass during composite with vertex colors, how about darkening the diffuse stage of each pass by 50 percent? The result should be equivalent. It should look something like this...

translucent/example

{

    // first pass

    {
        blend    bumpmap
        map    normalmap.tga
    }
    {
        blend    diffusemap
        map    diffusemap.tga
        rgb    0.5
    }

    // second pass
    // the scale function here is "inverting" the normal map so that it catches light from the opposite side.

    {
        blend    bumpmap
        map    scale(normalmap.tga, 1, 1, 0, 1)
    }
    {
        blend    diffusemap
        map    diffusemap.tga
        rgb    0.5
    }

Edited July 20, 2016 by rich_is_bored

[nbohr1more]

Oh!

 

So the second diffuse stage acts like an additive blend (because the light passes are additive)?

 

Interesting. I guess that would also mean that you could ramp to black on each diffuse stage and the result would

be like blending. Not that useful in the context of a single material though (outside of this idea).