Sampling a Cubemap in a Shader

artoo

I know it is possible to pull textures into a shader:

I reference it using

I have a vertex program that passes texcoord0 and texdim0 values to my fragment program and then i add in a sampler:
uniform sampler2D tex0;

and then i can reference this in my fragment program with texture2D

How do I amend this so I can sample from a cubemap?

Rob Ramirez

i don't think you can declare a cubemap inline like normal textures. just create a jit.gl.cubemap in your patch, and send it's output to your object. you can then declare it as a uniform in your shader (same as other textures)

<param name="cubemap" type="int" default="0"/> <bind param="cubemap" program="fs" /> ... uniform samplerCube cubemap; vec4 cmapval = textureCube(cubemap, tc);

Rob Ramirez

here's the basic texture generated by gl.material for a diffuse inptut and environment input (i.e. cubemap)

<jittershader name="jit.gl.material.jxs">
    <description>
        material's system code generated JXS file
    </description>    
    <param name="eta" type="float" default="1.2000000476837"/>
    <param name="fresnel" type="float" default="0.30000001192093"/>
    <param name="environment" type="int" default="1"/>
    <param name="diffuse" type="int" default="0"/>
    <param name="jit_INVERSE_VMAT" type="mat4" state="VIEW_MATRIX" transform="INVERSE"/>
    
    
    <language name="glsl" version="1.0">
        <bind param="eta" program="fs" />
        <bind param="fresnel" program="fs" />
        <bind param="environment" program="fs" />
        <bind param="diffuse" program="fs" />
        <bind param="jit_INVERSE_VMAT" program="fs" />
        
        <program name="vs" type="vertex">
        <![CDATA[
            #version 120            
            varying vec3 jit_Surface_normal;
            varying vec2 jit_Surface_texcoord0;
            varying vec4 jit_Surface_position;
            
            void main() {
                jit_Surface_normal = gl_NormalMatrix*gl_Normal;
                jit_Surface_texcoord0 = vec2(gl_TextureMatrix[0] * gl_MultiTexCoord0);
                jit_Surface_position = gl_ModelViewMatrix*gl_Vertex;
                gl_Position = ftransform();
            }
        ]]>
        </program>
        <program name="fs" type="fragment">
        <![CDATA[
            
            #version 120
            #define PI (3.1415926535898)
                #define jit_LightModel gl_LightModel
            struct Material{
                vec4 color;
            };
            struct Light{
                vec4 ambient;
                vec4 diffuse;
                vec4 specular;
                vec3 toEyePosition;
            };
            
                
            ///////////////////////////////////
            // Diffuse Shading Models
            
            // aka Lambertian
            float lambertian(vec3 Nn, vec3 L) {
                return max(dot(Nn, L), 0.);
            }
                
                
            ///////////////////////////////////
            // Specular Shading Models
            
            // aka Blinn (really Blinn-Phong)
            float blinn(vec3 Vn, vec3 Nn, vec3 L, float Ns) {
                vec3 H = normalize(L + Vn);
                return pow(max(dot(Nn, H), 0.), Ns);
            }
            
            Material jit_Material;
            Light jit_Light[8];    
            
            
            uniform float eta;
            uniform float fresnel;
            uniform sampler2DRect diffuse;
            uniform samplerCube environment;
            uniform mat4 jit_INVERSE_VMAT;
            varying vec3 jit_Surface_normal;
            varying vec2 jit_Surface_texcoord0;
            varying vec4 jit_Surface_position;
            
            void main() {
                jit_Material.color = vec4(0., 0., 0., 0.);
                vec3 jit_Surface_view = -vec3(jit_Surface_position);
                vec3 Vn = normalize(jit_Surface_view);
                vec3 Nn = normalize(jit_Surface_normal);
                vec3 Pn = normalize(vec3(jit_Surface_position));
                vec3 Reflect = vec3(jit_INVERSE_VMAT*vec4(reflect(Pn, Nn), 0.0));
                vec3 Refract = vec3(jit_INVERSE_VMAT*vec4(refract(-Vn, Nn, eta), 0.0));
                vec4 env = mix(textureCube(environment, Reflect), textureCube(environment, Refract), fresnel);
                vec4 diffuse_tex = texture2DRect(diffuse, jit_Surface_texcoord0);
                jit_Light[0].toEyePosition = normalize(jit_Surface_position.xyz - gl_LightSource[0].position.xyz);
                float d6 = length(jit_Surface_position.xyz-gl_LightSource[0].position.xyz);
                float atten7 = gl_LightSource[0].constantAttenuation+gl_LightSource[0].linearAttenuation*d6+gl_LightSource[0].quadraticAttenuation*d6*d6;
                atten7 = 1.0/atten7;
                jit_Light[0].ambient = gl_LightSource[0].ambient*atten7;
                jit_Light[0].diffuse = gl_LightSource[0].diffuse*atten7;
                jit_Light[0].specular = gl_LightSource[0].specular*atten7;
                vec3 jit_Surface_toLight1 = -jit_Light[0].toEyePosition;
                vec3 L2 = normalize(jit_Surface_toLight1);
                float shininess3 = gl_FrontMaterial.shininess;
                float mat_diffuse4 = lambertian(Nn, L2);
                float mat_specular5 = blinn(Vn, Nn, L2, shininess3);
                jit_Material.color += gl_FrontMaterial.emission;
                jit_Material.color += gl_FrontMaterial.ambient*(jit_Light[0].ambient+jit_LightModel.ambient)*diffuse_tex;
                jit_Material.color += gl_FrontMaterial.diffuse*jit_Light[0].diffuse*mat_diffuse4*env*diffuse_tex;
                jit_Material.color += gl_FrontMaterial.specular*jit_Light[0].specular*mat_specular5;
                gl_FragColor = jit_Material.color;
            }
        ]]>
        </program>
    </language>
</jittershader>