struct shader {
    shader() :
        shader_vert(0),
        shader_frag(0),
        shader_prog(0)
    {}
    void vsource(const char *data) { shader_vert_s = new char[strlen(data)]; strcpy(shader_vert_s, data); }
    void fsource(const char *data) { shader_frag_s = new char[strlen(data)]; strcpy(shader_frag_s, data); }

    void create ();

    GLenum shader_vert;
    GLenum shader_frag;
    GLenum shader_prog;
    char  *shader_vert_s;
    char  *shader_frag_s;
    };

    void shader::create()
    {
    int len = strlen(shader_vert_s);

    shader_prog = glCreateProgramObjectARB();
    shader_vert = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
    shader_frag = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);

    glShaderSourceARB(shader_vert, 1, (const GLchar**)&shader_vert_s, &len);
    len = strlen(shader_frag_s);
    glShaderSourceARB(shader_frag, 1, (const GLchar**)&shader_frag_s, &len);

    glCompileShaderARB(shader_vert);
    glCompileShaderARB(shader_frag);
    glAttachObjectARB(shader_prog, shader_vert);
    glAttachObjectARB(shader_prog, shader_frag);
    glLinkProgramARB(shader_prog);

    char info[1024];
    int  ilen=0;
    glGetInfoLogARB(shader_vert, 1024-1, &ilen, info);
    printf("error: %s\n", info);
    glGetInfoLogARB(shader_frag, 1024-1, &ilen, info);
    printf("error: %s\n", info);
    }


    shader world;

    world.vsource(
        "void main()\n"
        "{\n"
            "\tgl_TexCoord[0] = gl_MultiTexCoord0;\n"
            "\tgl_TexCoord[1] = gl_MultiTexCoord1;\n"
            "\tgl_Position    = gl_ModelViewProjectionMatrix * gl_Vertex;\n"
        "}\n"
    );
    world.fsource(
        "#version 120\n"
        "uniform sampler2D tex_n;\n"
        "uniform sampler2D tex_l;\n"
        "\n"
        "void main()\n"
        "{\n"
            "\tvec4 tx1 = texture2D(tex_n, gl_TexCoord[0].st);\n"
            "\tvec4 tx2 = texture2D(tex_l, gl_TexCoord[1].st);\n"
            "\tgl_FragColor = tx1 + tx2;\n"
        "}\n"
    );

    world.create();

    // render
    glUseProgramObjectARB(world.shader_prog);
    renderq(w, h);
    glUseProgramObjectARB(0);

    // map render
void renderq(int w, int h)
{
    glEnableClientState(GL_VERTEX_ARRAY);

    visiblecubes(worldroot, hdr.worldsize/2, 0, 0, 0, w, h);

    vtxarray *va = visibleva;
    while(va)
    {
        glVertexPointer  (3, GL_FLOAT, sizeof(vertex), &(va->vbuf[0].x));
        glTexCoordPointer(2, GL_FLOAT, sizeof(vertex), &(va->vbuf[0].u));

        lodlevel &lod = va->curlod ? va->l1 : va->l0;

        extern vector<GLuint> lmtexids;

        unsigned short *ebuf = lod.ebuf;
        for(int i=0; i < lod.texs; i++)
        {
            glActiveTexture(GL_TEXTURE0);
            glBindTexture(GL_TEXTURE_2D, lookuptexture(lod.eslist[i].texture)->gl);
            glEnable(GL_TEXTURE_2D);

            glActiveTexture(GL_TEXTURE1);
            glBindTexture(GL_TEXTURE_2D, lmtexids[lod.eslist[i].lmid]);
            glEnable(GL_TEXTURE_2D);

            glUniform1iARB(glGetUniformLocationARB(world.shader_prog, "tex_n"), 0);
            glUniform1iARB(glGetUniformLocationARB(world.shader_prog, "tex_l"), 1);

            for(int l=0; l<3; l++) if (lod.eslist[i].length[l])
            {
                glDrawElements(GL_QUADS, lod.eslist[i].length[l], GL_UNSIGNED_SHORT, ebuf);
                ebuf += lod.eslist[i].length[l];  // Advance to next array.
                glde++;
            }
        }
        va = va->next;
    }
    glActiveTexture(GL_TEXTURE0);
    glDisable(GL_TEXTURE_2D);
    glActiveTexture(GL_TEXTURE1);
    glDisable(GL_TEXTURE_2D);
    glActiveTexture(GL_TEXTURE0);
    glDisableClientState(GL_VERTEX_ARRAY);
}

// all textures in map are solid colors, why?