test/main.cpp - platform/external/mesa3d - Git at Google

 #include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
 #include <math.h>
 #include <unistd.h>


 #define DRAW_TO_SCREEN 1
 #define USE_16BPP_TEXTURE 0 // forces texture to load as 16bpp, define before image_file.h

 #ifdef __arm__
 #define PATH_PREFIX "/data/"
 #else
 #define PATH_PREFIX ""
 #endif

 #include <pixelflinger2/pixelflinger2_interface.h>
 #include "image_file.h"
 #include "m_matrix.h"

 #ifdef __arm__
 extern "C" int SetupDrawingSurface(unsigned * width, unsigned * height, unsigned * bpp);
 extern "C" void * PresentDrawingSurface();
 extern "C" void DisposeDrawingSurface();
 #endif

 GGLInterface * ggl = NULL;

 gl_shader * load_shader(const unsigned type, const char * path)
 {
    FILE * file = NULL;
    file = fopen(path, "rb");
    if (!file)
       printf("failed to open '%s' \n", path);

    fseek(file, 0, SEEK_END);
    unsigned fileSize = ftell(file);
    fseek(file, 0, SEEK_SET);

    char * shader_string = (char *)malloc(fileSize + 1);
    printf("fileSize=%dB \n", fileSize);
    int read = fread(shader_string, 1, fileSize, file);
    shader_string[read] = '\0';
    fclose(file);

    puts(shader_string);
    puts("compiling shader...");

    gl_shader * shader = ggl->ShaderCreate(ggl, type);
    const char * infoLog = NULL;
    GLboolean compileStatus = ggl->ShaderCompile(ggl, shader, shader_string, &infoLog);

    printf("shader.InfoLog = %s \nshader.CompileStatus = %d \n\n",
           infoLog, compileStatus);
    if (!compileStatus)
       exit(1);

    free(shader_string);
    return shader;
 }

 gl_shader_program * init_shader()
 {
    puts("\n -- load vertex shader -- \n");
    struct gl_shader * vertShader = load_shader(GL_VERTEX_SHADER, PATH_PREFIX"vs.vert");

    puts("\n -- load fragment shader -- \n");
    struct gl_shader * fragShader =  load_shader(GL_FRAGMENT_SHADER, PATH_PREFIX"fs.frag");

    gl_shader_program * program = ggl->ShaderProgramCreate(ggl);
    // current scan_test assumes the following attribute layout
    ggl->ShaderAttributeBind(program, 0, "aPosition");
    ggl->ShaderAttributeBind(program, 1, "aTexCoord");

    puts("\n -- linking -- \n");
    ggl->ShaderAttach(ggl, program, vertShader);
    ggl->ShaderAttach(ggl, program, fragShader);
    const char * infoLog = NULL;
    GLboolean linkStatus = ggl->ShaderProgramLink(program, &infoLog);

    printf("finished linking, LinkStatus=%d \n %s \n", linkStatus, infoLog);

    if (!linkStatus)
       exit(1);

    ggl->ShaderUse(ggl, program);

    return program;
 }

 void test_scan()
 {
    srand(1337);
    ggl = CreateGGLInterface();

    GGLSurface frameSurface = {0};
 #if defined __arm__ && DRAW_TO_SCREEN
    unsigned width = 0, height = 0, bpp = 0;
    SetupDrawingSurface(&width, &height, &bpp);
    frameSurface.data = PresentDrawingSurface();
 #else
    const unsigned width = 640, height = 400;
    frameSurface.data = (unsigned int *)malloc(width * height * 4);
 #endif

    frameSurface.format = GGL_PIXEL_FORMAT_RGBA_8888;
    frameSurface.width = width;
    frameSurface.height = height;

    GGLSurface depthSurface = {0};
    depthSurface.width = width;
    depthSurface.height = height;
    depthSurface.format = GGL_PIXEL_FORMAT_Z_32;
    depthSurface.data = malloc(width * height * 4);
    ggl->SetBuffer(ggl, GL_DEPTH_BUFFER_BIT, &depthSurface);

    GGLSurface stencilSurface = {0};
    stencilSurface.width = width;
    stencilSurface.height = height;
    stencilSurface.format = GGL_PIXEL_FORMAT_S_8;
    stencilSurface.data = malloc(width * height);

    ggl->SetBuffer(ggl, GL_STENCIL_BUFFER_BIT, &stencilSurface);
    ggl->ClearStencil(ggl, 0);
    ggl->StencilFuncSeparate(ggl, GL_FRONT_AND_BACK, GL_EQUAL, 0, 0xff);
    ggl->StencilOpSeparate(ggl, GL_FRONT_AND_BACK, GL_INCR, GL_KEEP, GL_KEEP);
    //ggl->EnableDisable(ggl, GL_STENCIL_TEST, true);

    gl_shader_program * program = init_shader(); // change states after to test code cache

    GGLTexture texture = {0};
    LoadTGA(PATH_PREFIX"android.tga", &texture.width, &texture.height,
            &texture.levels);
 //    for (unsigned i = 0; i < texture.width * texture.height; i++)
 //    {
 //        const unsigned x = i % 480, y = i / 480;
 //        ((unsigned *)texture.levels[0])[i] = ((x + y) % 2) * 0xffffff | 0xff000000;
 //    }
 #if USE_16BPP_TEXTURE
    texture.format = GGL_PIXEL_FORMAT_RGB_565;
 #else
    texture.format = GGL_PIXEL_FORMAT_RGBA_8888;
 #endif
    texture.type = GL_TEXTURE_2D;
    texture.levelCount = 1;
    texture.wrapS = texture.wrapT = GGLTexture::GGL_REPEAT; // repeat = 0 fastest, clamp = 1, mirrored = 2
    texture.minFilter = texture.magFilter = GGLTexture::GGL_NEAREST; // nearest = 0, linear = 1
    //texture.levelCount = GenerateMipmaps(texture.levels, texture.width, texture.height);

    //    static unsigned texels [6] = {0xff0000ff, 0xff00ff00, 0xffff0000,
    //    0xff00ffff, 0xffffff00, 0xffff00ff};
    //    memcpy(texture.levels[0], texels, sizeof texels);
    //    texture.format = GGL_PIXEL_FORMAT_RGBA_8888;
    //    texture.width = texture.height = 1;
    //texture.height /= 6;
    //texture.type = GL_TEXTURE_CUBE_MAP;

    ggl->SetSampler(ggl, 0, &texture);

    //ggl->EnableDisable(ggl, GL_CULL_FACE, true);
    ggl->FrontFace(ggl, GL_CW);
    ggl->CullFace(ggl, GL_BACK);

    ggl->EnableDisable(ggl, GL_BLEND, true);
    ggl->BlendFuncSeparate(ggl, GL_ONE_MINUS_CONSTANT_COLOR, GL_CONSTANT_COLOR,
                           GL_ONE_MINUS_CONSTANT_COLOR, GL_CONSTANT_COLOR);
    ggl->BlendEquationSeparate(ggl, GL_FUNC_ADD, GL_FUNC_ADD);
    ggl->BlendColor(ggl, 0.7, 0.7, 0.7, 1);

    ggl->SetBuffer(ggl, GL_COLOR_BUFFER_BIT, &frameSurface);


    ggl->EnableDisable(ggl, GL_DEPTH_TEST, true);
    ggl->DepthFunc(ggl, GL_LESS);

    ggl->DepthRangef(ggl, 0.0f, 1.0f);
    ggl->Viewport(ggl, 0, 0, width, height);

    const unsigned scale = 1, portWidth = 640, portHeight = 400;
    //const unsigned scale = 1, portWidth = width / scale, portHeight = height / scale;
    ggl->Viewport(ggl, 0, 0, portWidth, portHeight);
    //ggl->Viewport(ggl, (width - portWidth) / 2, (height - portHeight) / 2,
    //portWidth, portHeight);

    GLmatrix m0, m1, m2, m3, m4;
    _math_matrix_ctr(&m0);
    _math_matrix_ctr(&m1);
    _math_matrix_ctr(&m2);
    _math_matrix_ctr(&m3);
    _math_matrix_ctr(&m4);

    int uMatrixLoc = ggl->ShaderUniformLocation(program, "uMatrix");
    int uRotMLoc = ggl->ShaderUniformLocation(program, "uRotM");
    int uTLoc = ggl->ShaderUniformLocation(program, "t");

    GGLTexture cubeTexture = {GL_TEXTURE_CUBE_MAP, GGL_PIXEL_FORMAT_RGBA_8888, 1, 1, 1, NULL, GGLTexture::GGL_CLAMP_TO_EDGE, GGLTexture::GGL_MIRRORED_REPEAT, GGLTexture::GGL_LINEAR, GGLTexture::GGL_LINEAR};
    unsigned cubeTextureSurface [6] = {0xff0000ff, 0xff00ff00, 0xffff0000,
                                       0xff00ffff, 0xffffff00, 0xffff00ff
                                      };
    void * levels [1] = {cubeTextureSurface};
    cubeTexture.levels = levels;
    if (program) {
       ggl->ShaderUniformMatrix(program, 4, 4, uMatrixLoc, 1, GL_FALSE, m0.m);
       int sampler2dLoc = ggl->ShaderUniformLocation(program, "sampler2d");
       int samplercubeLoc = ggl->ShaderUniformLocation(program, "samplercube");
       int samplerUnit = -1;
       if (0 <= sampler2dLoc) { // set 2d texture to sampler if used
          samplerUnit = sampler2dLoc;//ggl->ShaderUniformGetiv(ggl, program, sampler2dLoc, &samplerUnit);
          ggl->SetSampler(ggl, samplerUnit, &texture);
       }
       if (0 <= samplercubeLoc) { // set cube texture to sampler if used
          samplerUnit = samplercubeLoc;//ggl->ShaderUniformGetiv(ggl, program, samplercubeLoc, &samplerUnit);
          ggl->SetSampler(ggl, samplerUnit, &cubeTexture);
       }
    }

    VertexInput v0, v1, v2, v3;
    const float z = +0.5;
 //    const float vcMin = -10, vcMax = 10;
 //    const float tcMin = -4.5, tcMax = 5.5;
    const float vcMin = -1, vcMax = 1;
    const float tcMin = 0, tcMax = 1;
    v0.attributes[0] = Vector4_CTR(vcMin,vcMin,z,1);
    v0.attributes[1] = Vector4_CTR(tcMin,tcMin,0,1);

    v1.attributes[0] = Vector4_CTR(vcMin,vcMax,z,1);
    v1.attributes[1] = Vector4_CTR(tcMin,tcMax,0,1);

    v2.attributes[0] = Vector4_CTR(vcMax,vcMax,z,1);
    v2.attributes[1] = Vector4_CTR(tcMax,tcMax,0,1);

    v3.attributes[0] = Vector4_CTR(vcMax,vcMin,z,1);
    v3.attributes[1] = Vector4_CTR(tcMax,tcMin,0,1);

    VertexInput vertices[8] = {
       //  pos         texcoord
       {{Vector4_CTR(-1,-1,-1,1), Vector4_CTR(tcMin,tcMin,0,1)}},
       {{Vector4_CTR(-1,-1, 1,1), Vector4_CTR(tcMin,tcMax,0,1)}},
       {{Vector4_CTR( 1,-1, 1,1), Vector4_CTR(tcMax,tcMax,0,1)}},
       {{Vector4_CTR( 1,-1,-1,1), Vector4_CTR(tcMax,tcMin,0,1)}},
       {{Vector4_CTR(-1, 1,-1,1), Vector4_CTR(tcMin,tcMin,0,1)}},
       {{Vector4_CTR(-1, 1, 1,1), Vector4_CTR(tcMin,tcMax,0,1)}},
       {{Vector4_CTR( 1, 1, 1,1), Vector4_CTR(tcMax,tcMax,0,1)}},
       {{Vector4_CTR( 1, 1,-1,1), Vector4_CTR(tcMax,tcMin,0,1)}},
    };

    unsigned indices[] = {
       0,1,2,  0,2,3,
       4,5,6,  4,6,7,
       0,3,4,  3,4,7,
       1,2,5,  2,5,6,
       0,1,4,  1,4,5,
       2,3,6,  3,6,7,
    };

    Vector4 pos = v0.attributes[0];
    ggl->ViewportTransform(ggl, &pos);

    ggl->ClearColor(ggl, 0.8f, 0.8f, 1, 1);
    //ggl->ClearDepthf(ggl, pos.z + 0.0001f); // when there is no transform in vs
    ggl->ClearDepthf(ggl, 1);
    ggl->EnableDisable(ggl, GL_BLEND, false);
    ggl->EnableDisable(ggl, GL_DEPTH_TEST, true);
    ggl->EnableDisable(ggl, GL_STENCIL_TEST, false);


    ggl->DrawTriangle(ggl, &v0, &v0, &v0); // cause re-JIT to not mess up timing

    puts("\n -- begin rendering -- \n");

    unsigned frames = 0;
    clock_t c0 = clock();

 #ifdef __arm__
    //while (true)
 #endif
    for (
 #ifdef __arm__
       unsigned i = 0; i <= 90; i++
 #else
       unsigned i = 0; i <= 10; i+= 1
 #endif
    ) {
 //      printf("frame=%d \n", i);
       ggl->Clear(ggl, GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
       //ggl->Clear(ggl, GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);

       _math_matrix_set_identity(&m0);
       _math_matrix_set_identity(&m1);
       _math_matrix_set_identity(&m2);
       //_math_matrix_set_identity(&m3);


       //_math_matrix_ortho(&m0, 0, 480, 0, 800, 0.1, 1);
       _math_matrix_perspective(&m0, 60, (float)width / height, 0.1f, 100);
       //float ratio = (float)width / height;
       //_math_matrix_frustum(&m0, -ratio, ratio, -1, 1, 3, 7);

       _math_matrix_lookat(&m1, 0, 0, -6,
                           0, 0, 2,
                           0, 1, 0);

       //_math_matrix_scale(&m0, 0.2, 0.2, 0.2);
       //_math_matrix_translate(&m2, 1, 1, 1);
       _math_matrix_rotate(&m2, i * 2, 1, 2, 3);
       //_math_matrix_rotate(&m2, i, 0, 0, 1);

       // matrix on the right is applied to vector first
       _math_matrix_mul_matrix(&m3, &m1, &m2);
       _math_matrix_mul_matrix(&m4, &m0, &m3);


       float t = i * 0.6f;
       if (program) {
          ggl->ShaderUniformMatrix(program, 4, 4, uMatrixLoc, 1, GL_FALSE, m4.m);
          ggl->ShaderUniformMatrix(program, 4, 4, uRotMLoc, 1, GL_FALSE, m2.m);
          ggl->ShaderUniform(program, uTLoc, 1, &t, GL_FLOAT);
       }

       //ggl->EnableDisable(ggl, GL_BLEND, true);
       //ggl->EnableDisable(ggl, GL_BLEND, false);
       //ggl->EnableDisable(ggl, GL_BLEND, (i + 1) % 2);
       //ggl->EnableDisable(ggl, GL_STENCIL_TEST, i / 2 % 2);
       //ggl->BlendColor(ggl,(float)i / 10, (float) i / 15, (float)i < 20, 1);

       for (unsigned j = 0; j < sizeof(indices) / sizeof(*indices); j += 3)
          ggl->DrawTriangle(ggl, vertices + indices[j], vertices + indices[j+1], vertices + indices[j+2]);

       // including clear, depth, and other ops, direct ScanLine calls are 4% faster than DrawTriangle
       // X86 memcpy is 0.60ms vs 4.90ms for 480*800 fs texturing
       // Nexus One memcpy is 8.7ms vs 71ms for 480*800 fs texturing
       // Nexus One fixed point 480*800 fs texturing is 61ms
       // texture * vtexcoord is 70ms, floating texture * vtexcoord is 170ms
       //memcpy(((GGLContext *)ggl)->frameSurface.data, ((GGLContext *)ggl)->textureState.textures[0].levels[0], width * height * 4);

 //      ggl->DrawTriangle(ggl, &v0, &v1, &v2);
 //      ggl->DrawTriangle(ggl, &v2, &v3, &v0);

 //        VertexOutput tl = {0, Vector4(0,0,0,1), Vector4(0,0,0,1)};
 //        VertexOutput tr = {0, Vector4(portWidth - 1,0,0,1), Vector4(1,0,0,1)};
 //        VertexOutput bl = {0, Vector4(0, portHeight-1,0,1), Vector4(0,1,0,1)};
 //        VertexOutput br = {0, Vector4(portWidth - 1, portHeight - 1,0,1), Vector4(1,1,0,1)};
 //        ggl->RasterTrapezoid(ggl, &tl, &tr, &bl, &br);
 //
 //        for (unsigned y = 0; y < portHeight; y++)
 //        {
 //            VertexOutput vo0 = {0, Vector4(0,y,0,1), Vector4(0,float(y) / (portHeight - 1),0,1)};
 //            VertexOutput vo1 = {0, Vector4(portWidth - 1,y,0,1), Vector4(1,float(y) / (portHeight - 1),0,1)};
 //            ggl->ScanLine(ggl, &vo0, &vo1);
 //        }

 //#if !USE_LLVM_TEXTURE_SAMPLER
 //        extern const GGLContext * textureGGLContext;
 //        textureGGLContext = (GGLContext *)ggl;
 //#endif
 //        for (unsigned y = 0; y < height; y++)
 //            for (unsigned x = 0; x < width; x++)
 //            {
 //                const unsigned index = y * width + x;
 ////                ((unsigned *)frameSurface.data)[index] = ((unsigned *)textureGGLContext->textureState.textures[0].levels[0])[index];
 //                Vector4 tc(float(x) / (width - 1), float(y) / (height - 1), 0, 0);
 //                unsigned color[4];
 //                tex2d_int32<GGL_PIXEL_FORMAT_RGBA_8888>(color, (const float *)&tc, 0);
 //                ((unsigned *)frameSurface.data)[index] = color[0];
 //            }
 //#if !USE_LLVM_TEXTURE_SAMPLER
 //        textureGGLContext = NULL;
 //#endif

       frames++;
       if (scale > 1)
          for (int y = portHeight - 1; y >= 0; y--)
             for (int x = portWidth - 1; x >= 0; x--) {
                unsigned pixel = ((unsigned *)frameSurface.data)[y * width + x];
                for (unsigned xx = 0; xx < scale; xx++)
                   for (unsigned yy = 0; yy < scale; yy++)
                      ((unsigned *)frameSurface.data)[(y * scale + yy) * width + x * scale + xx] = pixel;
             }

 #if defined __arm__ && DRAW_TO_SCREEN
       frameSurface.data = PresentDrawingSurface();
       ggl->SetBuffer(ggl, GL_COLOR_BUFFER_BIT, &frameSurface);
 #endif
       //puts("frame completed, press ENTER"); getchar();
    }

    /*
    #ifndef __arm__
    __attribute__ ((aligned (16))) // LLVM generates movaps on X86, needs 16 bytes align
    #endif
    float data [64];
    ShaderFunction_t function = ((GGLContext *)ggl)->glCtx->Shader.CurrentProgram->GLVMFP->function;
    float * inputs = data;
    float * outputs = data + 24;
    float * constants = data + 48;
    const unsigned wd = 200, ht = 200;
     for (unsigned y = 0; y < ht; y++)
    	for (unsigned x = 0; x < wd; x++)
    {
    	inputs[4] = ((float)x) / wd;
    	inputs[5] = ((float)y) / ht;
    	inputs[6] = 0;
    	inputs[7] = 1;
    	constants[0] = 0.0f;
    	function(inputs, outputs, constants);
    	unsigned r = outputs[0] * 255;
    	unsigned g = outputs[1] * 255;
    	unsigned b = outputs[2] * 255;
    	unsigned a = outputs[3] * 255;
    	((unsigned *)frameSurface.data)[y * width + x] = (a << 24) | (b << 16) | (g << 8) | r;
    }
    printf("gl_FragColor=%.2f, %.2f, %.2f %.2f \n", outputs[0], outputs[1], outputs[2], outputs[3]);
    frames = 1;
    //*/

    float elapsed = (float)(clock() - c0) / CLOCKS_PER_SEC;
    printf ("\n *** test_scan elapsed CPU time: %fs \n *** fps=%.2f, tpf=%.2fms \n",
            elapsed, frames / elapsed, elapsed / frames * 1000);
 #if USE_16BPP_TEXTURE
    puts("USE_16BPP_TEXTURE");
 #endif
 #ifdef __arm__
    SaveBMP("/sdcard/mesa.bmp", (unsigned *)frameSurface.data, frameSurface.width, frameSurface.height);
 #else
    SaveBMP("mesa.bmp", (unsigned *)frameSurface.data, frameSurface.width, frameSurface.height);
 #endif

    ggl->SetBuffer(ggl, GL_COLOR_BUFFER_BIT, NULL);
 #if defined __arm__ && DRAW_TO_SCREEN
    DisposeDrawingSurface();
 #else
    free(frameSurface.data);
 #endif

    ggl->SetBuffer(ggl, GL_DEPTH_BUFFER_BIT, NULL);
    free(depthSurface.data);

    ggl->SetBuffer(ggl, GL_STENCIL_BUFFER_BIT, NULL);
    free(stencilSurface.data);

    if (program)
       ggl->ShaderProgramDelete(ggl, program);

    free(texture.levels);

    DestroyGGLInterface(ggl);
    ggl = NULL;
 }

 extern "C" int cmain(int,char**);

 #include "llvm/LLVMContext.h"

 void GLContextDctr();

 extern "C" void hieralloc_report(const void *, FILE *);
 extern "C" void hieralloc_report_brief(const void *, FILE *);

 int main (int argc, char * const argv[])
 {
    cmain(0,NULL);

 //   contextless_test();

 //   contextless_test();

    test_scan();

 //   hieralloc_report(NULL, stdout);
    hieralloc_report_brief(NULL, stdout);
    puts("mesa done");
    return 0;
 }
	#include <assert.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <time.h>
	#include <math.h>
	#include <unistd.h>


	#define DRAW_TO_SCREEN 1
	#define USE_16BPP_TEXTURE 0 // forces texture to load as 16bpp, define before image_file.h

	#ifdef __arm__
	#define PATH_PREFIX "/data/"
	#else
	#define PATH_PREFIX ""
	#endif

	#include <pixelflinger2/pixelflinger2_interface.h>
	#include "image_file.h"
	#include "m_matrix.h"

	#ifdef __arm__
	extern "C" int SetupDrawingSurface(unsigned * width, unsigned * height, unsigned * bpp);
	extern "C" void * PresentDrawingSurface();
	extern "C" void DisposeDrawingSurface();
	#endif

	GGLInterface * ggl = NULL;

	gl_shader * load_shader(const unsigned type, const char * path)
	{
	FILE * file = NULL;
	file = fopen(path, "rb");
	if (!file)
	printf("failed to open '%s' \n", path);

	fseek(file, 0, SEEK_END);
	unsigned fileSize = ftell(file);
	fseek(file, 0, SEEK_SET);

	char * shader_string = (char *)malloc(fileSize + 1);
	printf("fileSize=%dB \n", fileSize);
	int read = fread(shader_string, 1, fileSize, file);
	shader_string[read] = '\0';
	fclose(file);

	puts(shader_string);
	puts("compiling shader...");

	gl_shader * shader = ggl->ShaderCreate(ggl, type);
	const char * infoLog = NULL;
	GLboolean compileStatus = ggl->ShaderCompile(ggl, shader, shader_string, &infoLog);

	printf("shader.InfoLog = %s \nshader.CompileStatus = %d \n\n",
	infoLog, compileStatus);
	if (!compileStatus)
	exit(1);

	free(shader_string);
	return shader;
	}

	gl_shader_program * init_shader()
	{
	puts("\n -- load vertex shader -- \n");
	struct gl_shader * vertShader = load_shader(GL_VERTEX_SHADER, PATH_PREFIX"vs.vert");

	puts("\n -- load fragment shader -- \n");
	struct gl_shader * fragShader = load_shader(GL_FRAGMENT_SHADER, PATH_PREFIX"fs.frag");

	gl_shader_program * program = ggl->ShaderProgramCreate(ggl);
	// current scan_test assumes the following attribute layout
	ggl->ShaderAttributeBind(program, 0, "aPosition");
	ggl->ShaderAttributeBind(program, 1, "aTexCoord");

	puts("\n -- linking -- \n");
	ggl->ShaderAttach(ggl, program, vertShader);
	ggl->ShaderAttach(ggl, program, fragShader);
	const char * infoLog = NULL;
	GLboolean linkStatus = ggl->ShaderProgramLink(program, &infoLog);

	printf("finished linking, LinkStatus=%d \n %s \n", linkStatus, infoLog);

	if (!linkStatus)
	exit(1);

	ggl->ShaderUse(ggl, program);

	return program;
	}

	void test_scan()
	{
	srand(1337);
	ggl = CreateGGLInterface();

	GGLSurface frameSurface = {0};
	#if defined __arm__ && DRAW_TO_SCREEN
	unsigned width = 0, height = 0, bpp = 0;
	SetupDrawingSurface(&width, &height, &bpp);
	frameSurface.data = PresentDrawingSurface();
	#else
	const unsigned width = 640, height = 400;
	frameSurface.data = (unsigned int )malloc(width height * 4);
	#endif

	frameSurface.format = GGL_PIXEL_FORMAT_RGBA_8888;
	frameSurface.width = width;
	frameSurface.height = height;

	GGLSurface depthSurface = {0};
	depthSurface.width = width;
	depthSurface.height = height;
	depthSurface.format = GGL_PIXEL_FORMAT_Z_32;
	depthSurface.data = malloc(width * height * 4);
	ggl->SetBuffer(ggl, GL_DEPTH_BUFFER_BIT, &depthSurface);

	GGLSurface stencilSurface = {0};
	stencilSurface.width = width;
	stencilSurface.height = height;
	stencilSurface.format = GGL_PIXEL_FORMAT_S_8;
	stencilSurface.data = malloc(width * height);

	ggl->SetBuffer(ggl, GL_STENCIL_BUFFER_BIT, &stencilSurface);
	ggl->ClearStencil(ggl, 0);
	ggl->StencilFuncSeparate(ggl, GL_FRONT_AND_BACK, GL_EQUAL, 0, 0xff);
	ggl->StencilOpSeparate(ggl, GL_FRONT_AND_BACK, GL_INCR, GL_KEEP, GL_KEEP);
	//ggl->EnableDisable(ggl, GL_STENCIL_TEST, true);

	gl_shader_program * program = init_shader(); // change states after to test code cache

	GGLTexture texture = {0};
	LoadTGA(PATH_PREFIX"android.tga", &texture.width, &texture.height,
	&texture.levels);
	// for (unsigned i = 0; i < texture.width * texture.height; i++)
	// {
	// const unsigned x = i % 480, y = i / 480;
	// ((unsigned )texture.levels[0])[i] = ((x + y) % 2) 0xffffff \| 0xff000000;
	// }
	#if USE_16BPP_TEXTURE
	texture.format = GGL_PIXEL_FORMAT_RGB_565;
	#else
	texture.format = GGL_PIXEL_FORMAT_RGBA_8888;
	#endif
	texture.type = GL_TEXTURE_2D;
	texture.levelCount = 1;
	texture.wrapS = texture.wrapT = GGLTexture::GGL_REPEAT; // repeat = 0 fastest, clamp = 1, mirrored = 2
	texture.minFilter = texture.magFilter = GGLTexture::GGL_NEAREST; // nearest = 0, linear = 1
	//texture.levelCount = GenerateMipmaps(texture.levels, texture.width, texture.height);

	// static unsigned texels [6] = {0xff0000ff, 0xff00ff00, 0xffff0000,
	// 0xff00ffff, 0xffffff00, 0xffff00ff};
	// memcpy(texture.levels[0], texels, sizeof texels);
	// texture.format = GGL_PIXEL_FORMAT_RGBA_8888;
	// texture.width = texture.height = 1;
	//texture.height /= 6;
	//texture.type = GL_TEXTURE_CUBE_MAP;

	ggl->SetSampler(ggl, 0, &texture);

	//ggl->EnableDisable(ggl, GL_CULL_FACE, true);
	ggl->FrontFace(ggl, GL_CW);
	ggl->CullFace(ggl, GL_BACK);

	ggl->EnableDisable(ggl, GL_BLEND, true);
	ggl->BlendFuncSeparate(ggl, GL_ONE_MINUS_CONSTANT_COLOR, GL_CONSTANT_COLOR,
	GL_ONE_MINUS_CONSTANT_COLOR, GL_CONSTANT_COLOR);
	ggl->BlendEquationSeparate(ggl, GL_FUNC_ADD, GL_FUNC_ADD);
	ggl->BlendColor(ggl, 0.7, 0.7, 0.7, 1);

	ggl->SetBuffer(ggl, GL_COLOR_BUFFER_BIT, &frameSurface);


	ggl->EnableDisable(ggl, GL_DEPTH_TEST, true);
	ggl->DepthFunc(ggl, GL_LESS);

	ggl->DepthRangef(ggl, 0.0f, 1.0f);
	ggl->Viewport(ggl, 0, 0, width, height);

	const unsigned scale = 1, portWidth = 640, portHeight = 400;
	//const unsigned scale = 1, portWidth = width / scale, portHeight = height / scale;
	ggl->Viewport(ggl, 0, 0, portWidth, portHeight);
	//ggl->Viewport(ggl, (width - portWidth) / 2, (height - portHeight) / 2,
	//portWidth, portHeight);

	GLmatrix m0, m1, m2, m3, m4;
	_math_matrix_ctr(&m0);
	_math_matrix_ctr(&m1);
	_math_matrix_ctr(&m2);
	_math_matrix_ctr(&m3);
	_math_matrix_ctr(&m4);

	int uMatrixLoc = ggl->ShaderUniformLocation(program, "uMatrix");
	int uRotMLoc = ggl->ShaderUniformLocation(program, "uRotM");
	int uTLoc = ggl->ShaderUniformLocation(program, "t");

	GGLTexture cubeTexture = {GL_TEXTURE_CUBE_MAP, GGL_PIXEL_FORMAT_RGBA_8888, 1, 1, 1, NULL, GGLTexture::GGL_CLAMP_TO_EDGE, GGLTexture::GGL_MIRRORED_REPEAT, GGLTexture::GGL_LINEAR, GGLTexture::GGL_LINEAR};
	unsigned cubeTextureSurface [6] = {0xff0000ff, 0xff00ff00, 0xffff0000,
	0xff00ffff, 0xffffff00, 0xffff00ff
	};
	void * levels [1] = {cubeTextureSurface};
	cubeTexture.levels = levels;
	if (program) {
	ggl->ShaderUniformMatrix(program, 4, 4, uMatrixLoc, 1, GL_FALSE, m0.m);
	int sampler2dLoc = ggl->ShaderUniformLocation(program, "sampler2d");
	int samplercubeLoc = ggl->ShaderUniformLocation(program, "samplercube");
	int samplerUnit = -1;
	if (0 <= sampler2dLoc) { // set 2d texture to sampler if used
	samplerUnit = sampler2dLoc;//ggl->ShaderUniformGetiv(ggl, program, sampler2dLoc, &samplerUnit);
	ggl->SetSampler(ggl, samplerUnit, &texture);
	}
	if (0 <= samplercubeLoc) { // set cube texture to sampler if used
	samplerUnit = samplercubeLoc;//ggl->ShaderUniformGetiv(ggl, program, samplercubeLoc, &samplerUnit);
	ggl->SetSampler(ggl, samplerUnit, &cubeTexture);
	}
	}

	VertexInput v0, v1, v2, v3;
	const float z = +0.5;
	// const float vcMin = -10, vcMax = 10;
	// const float tcMin = -4.5, tcMax = 5.5;
	const float vcMin = -1, vcMax = 1;
	const float tcMin = 0, tcMax = 1;
	v0.attributes[0] = Vector4_CTR(vcMin,vcMin,z,1);
	v0.attributes[1] = Vector4_CTR(tcMin,tcMin,0,1);

	v1.attributes[0] = Vector4_CTR(vcMin,vcMax,z,1);
	v1.attributes[1] = Vector4_CTR(tcMin,tcMax,0,1);

	v2.attributes[0] = Vector4_CTR(vcMax,vcMax,z,1);
	v2.attributes[1] = Vector4_CTR(tcMax,tcMax,0,1);

	v3.attributes[0] = Vector4_CTR(vcMax,vcMin,z,1);
	v3.attributes[1] = Vector4_CTR(tcMax,tcMin,0,1);

	VertexInput vertices[8] = {
	// pos texcoord
	{{Vector4_CTR(-1,-1,-1,1), Vector4_CTR(tcMin,tcMin,0,1)}},
	{{Vector4_CTR(-1,-1, 1,1), Vector4_CTR(tcMin,tcMax,0,1)}},
	{{Vector4_CTR( 1,-1, 1,1), Vector4_CTR(tcMax,tcMax,0,1)}},
	{{Vector4_CTR( 1,-1,-1,1), Vector4_CTR(tcMax,tcMin,0,1)}},
	{{Vector4_CTR(-1, 1,-1,1), Vector4_CTR(tcMin,tcMin,0,1)}},
	{{Vector4_CTR(-1, 1, 1,1), Vector4_CTR(tcMin,tcMax,0,1)}},
	{{Vector4_CTR( 1, 1, 1,1), Vector4_CTR(tcMax,tcMax,0,1)}},
	{{Vector4_CTR( 1, 1,-1,1), Vector4_CTR(tcMax,tcMin,0,1)}},
	};

	unsigned indices[] = {
	0,1,2, 0,2,3,
	4,5,6, 4,6,7,
	0,3,4, 3,4,7,
	1,2,5, 2,5,6,
	0,1,4, 1,4,5,
	2,3,6, 3,6,7,
	};

	Vector4 pos = v0.attributes[0];
	ggl->ViewportTransform(ggl, &pos);

	ggl->ClearColor(ggl, 0.8f, 0.8f, 1, 1);
	//ggl->ClearDepthf(ggl, pos.z + 0.0001f); // when there is no transform in vs
	ggl->ClearDepthf(ggl, 1);
	ggl->EnableDisable(ggl, GL_BLEND, false);
	ggl->EnableDisable(ggl, GL_DEPTH_TEST, true);
	ggl->EnableDisable(ggl, GL_STENCIL_TEST, false);


	ggl->DrawTriangle(ggl, &v0, &v0, &v0); // cause re-JIT to not mess up timing

	puts("\n -- begin rendering -- \n");

	unsigned frames = 0;
	clock_t c0 = clock();

	#ifdef __arm__
	//while (true)
	#endif
	for (
	#ifdef __arm__
	unsigned i = 0; i <= 90; i++
	#else
	unsigned i = 0; i <= 10; i+= 1
	#endif
	) {
	// printf("frame=%d \n", i);
	ggl->Clear(ggl, GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);
	//ggl->Clear(ggl, GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT \| GL_STENCIL_BUFFER_BIT);

	_math_matrix_set_identity(&m0);
	_math_matrix_set_identity(&m1);
	_math_matrix_set_identity(&m2);
	//_math_matrix_set_identity(&m3);


	//_math_matrix_ortho(&m0, 0, 480, 0, 800, 0.1, 1);
	_math_matrix_perspective(&m0, 60, (float)width / height, 0.1f, 100);
	//float ratio = (float)width / height;
	//_math_matrix_frustum(&m0, -ratio, ratio, -1, 1, 3, 7);

	_math_matrix_lookat(&m1, 0, 0, -6,
	0, 0, 2,
	0, 1, 0);

	//_math_matrix_scale(&m0, 0.2, 0.2, 0.2);
	//_math_matrix_translate(&m2, 1, 1, 1);
	_math_matrix_rotate(&m2, i * 2, 1, 2, 3);
	//_math_matrix_rotate(&m2, i, 0, 0, 1);

	// matrix on the right is applied to vector first
	_math_matrix_mul_matrix(&m3, &m1, &m2);
	_math_matrix_mul_matrix(&m4, &m0, &m3);


	float t = i * 0.6f;
	if (program) {
	ggl->ShaderUniformMatrix(program, 4, 4, uMatrixLoc, 1, GL_FALSE, m4.m);
	ggl->ShaderUniformMatrix(program, 4, 4, uRotMLoc, 1, GL_FALSE, m2.m);
	ggl->ShaderUniform(program, uTLoc, 1, &t, GL_FLOAT);
	}

	//ggl->EnableDisable(ggl, GL_BLEND, true);
	//ggl->EnableDisable(ggl, GL_BLEND, false);
	//ggl->EnableDisable(ggl, GL_BLEND, (i + 1) % 2);
	//ggl->EnableDisable(ggl, GL_STENCIL_TEST, i / 2 % 2);
	//ggl->BlendColor(ggl,(float)i / 10, (float) i / 15, (float)i < 20, 1);

	for (unsigned j = 0; j < sizeof(indices) / sizeof(*indices); j += 3)
	ggl->DrawTriangle(ggl, vertices + indices[j], vertices + indices[j+1], vertices + indices[j+2]);

	// including clear, depth, and other ops, direct ScanLine calls are 4% faster than DrawTriangle
	// X86 memcpy is 0.60ms vs 4.90ms for 480*800 fs texturing
	// Nexus One memcpy is 8.7ms vs 71ms for 480*800 fs texturing
	// Nexus One fixed point 480*800 fs texturing is 61ms
	// texture * vtexcoord is 70ms, floating texture * vtexcoord is 170ms
	//memcpy(((GGLContext )ggl)->frameSurface.data, ((GGLContext )ggl)->textureState.textures[0].levels[0], width * height * 4);

	// ggl->DrawTriangle(ggl, &v0, &v1, &v2);
	// ggl->DrawTriangle(ggl, &v2, &v3, &v0);

	// VertexOutput tl = {0, Vector4(0,0,0,1), Vector4(0,0,0,1)};
	// VertexOutput tr = {0, Vector4(portWidth - 1,0,0,1), Vector4(1,0,0,1)};
	// VertexOutput bl = {0, Vector4(0, portHeight-1,0,1), Vector4(0,1,0,1)};
	// VertexOutput br = {0, Vector4(portWidth - 1, portHeight - 1,0,1), Vector4(1,1,0,1)};
	// ggl->RasterTrapezoid(ggl, &tl, &tr, &bl, &br);
	//
	// for (unsigned y = 0; y < portHeight; y++)
	// {
	// VertexOutput vo0 = {0, Vector4(0,y,0,1), Vector4(0,float(y) / (portHeight - 1),0,1)};
	// VertexOutput vo1 = {0, Vector4(portWidth - 1,y,0,1), Vector4(1,float(y) / (portHeight - 1),0,1)};
	// ggl->ScanLine(ggl, &vo0, &vo1);
	// }

	//#if !USE_LLVM_TEXTURE_SAMPLER
	// extern const GGLContext * textureGGLContext;
	// textureGGLContext = (GGLContext *)ggl;
	//#endif
	// for (unsigned y = 0; y < height; y++)
	// for (unsigned x = 0; x < width; x++)
	// {
	// const unsigned index = y * width + x;
	//// ((unsigned )frameSurface.data)[index] = ((unsigned )textureGGLContext->textureState.textures[0].levels[0])[index];
	// Vector4 tc(float(x) / (width - 1), float(y) / (height - 1), 0, 0);
	// unsigned color[4];
	// tex2d_int32<GGL_PIXEL_FORMAT_RGBA_8888>(color, (const float *)&tc, 0);
	// ((unsigned *)frameSurface.data)[index] = color[0];
	// }
	//#if !USE_LLVM_TEXTURE_SAMPLER
	// textureGGLContext = NULL;
	//#endif

	frames++;
	if (scale > 1)
	for (int y = portHeight - 1; y >= 0; y--)
	for (int x = portWidth - 1; x >= 0; x--) {
	unsigned pixel = ((unsigned )frameSurface.data)[y width + x];
	for (unsigned xx = 0; xx < scale; xx++)
	for (unsigned yy = 0; yy < scale; yy++)
	((unsigned )frameSurface.data)[(y scale + yy) * width + x * scale + xx] = pixel;
	}

	#if defined __arm__ && DRAW_TO_SCREEN
	frameSurface.data = PresentDrawingSurface();
	ggl->SetBuffer(ggl, GL_COLOR_BUFFER_BIT, &frameSurface);
	#endif
	//puts("frame completed, press ENTER"); getchar();
	}

	/*
	#ifndef __arm__
	__attribute__ ((aligned (16))) // LLVM generates movaps on X86, needs 16 bytes align
	#endif
	float data [64];
	ShaderFunction_t function = ((GGLContext *)ggl)->glCtx->Shader.CurrentProgram->GLVMFP->function;
	float * inputs = data;
	float * outputs = data + 24;
	float * constants = data + 48;
	const unsigned wd = 200, ht = 200;
	for (unsigned y = 0; y < ht; y++)
	for (unsigned x = 0; x < wd; x++)
	{
	inputs[4] = ((float)x) / wd;
	inputs[5] = ((float)y) / ht;
	inputs[6] = 0;
	inputs[7] = 1;
	constants[0] = 0.0f;
	function(inputs, outputs, constants);
	unsigned r = outputs[0] * 255;
	unsigned g = outputs[1] * 255;
	unsigned b = outputs[2] * 255;
	unsigned a = outputs[3] * 255;
	((unsigned )frameSurface.data)[y width + x] = (a << 24) \| (b << 16) \| (g << 8) \| r;
	}
	printf("gl_FragColor=%.2f, %.2f, %.2f %.2f \n", outputs[0], outputs[1], outputs[2], outputs[3]);
	frames = 1;
	//*/

	float elapsed = (float)(clock() - c0) / CLOCKS_PER_SEC;
	printf ("\n * test_scan elapsed CPU time: %fs \n * fps=%.2f, tpf=%.2fms \n",
	elapsed, frames / elapsed, elapsed / frames * 1000);
	#if USE_16BPP_TEXTURE
	puts("USE_16BPP_TEXTURE");
	#endif
	#ifdef __arm__
	SaveBMP("/sdcard/mesa.bmp", (unsigned *)frameSurface.data, frameSurface.width, frameSurface.height);
	#else
	SaveBMP("mesa.bmp", (unsigned *)frameSurface.data, frameSurface.width, frameSurface.height);
	#endif

	ggl->SetBuffer(ggl, GL_COLOR_BUFFER_BIT, NULL);
	#if defined __arm__ && DRAW_TO_SCREEN
	DisposeDrawingSurface();
	#else
	free(frameSurface.data);
	#endif

	ggl->SetBuffer(ggl, GL_DEPTH_BUFFER_BIT, NULL);
	free(depthSurface.data);

	ggl->SetBuffer(ggl, GL_STENCIL_BUFFER_BIT, NULL);
	free(stencilSurface.data);

	if (program)
	ggl->ShaderProgramDelete(ggl, program);

	free(texture.levels);

	DestroyGGLInterface(ggl);
	ggl = NULL;
	}

	extern "C" int cmain(int,char**);

	#include "llvm/LLVMContext.h"

	void GLContextDctr();

	extern "C" void hieralloc_report(const void , FILE );
	extern "C" void hieralloc_report_brief(const void , FILE );

	int main (int argc, char * const argv[])
	{
	cmain(0,NULL);

	// contextless_test();

	// contextless_test();

	test_scan();

	// hieralloc_report(NULL, stdout);
	hieralloc_report_brief(NULL, stdout);
	puts("mesa done");
	return 0;
	}