From b341bc8271147be311b77937347f0f3f54aab749 Mon Sep 17 00:00:00 2001 From: David Li Date: Tue, 8 Feb 2011 14:25:22 -0800 Subject: Changed some states to enum; static gl_context for shader compiling/linking. Changed language version from 100 to 120. --- Android.mk | 1 + include/pixelflinger2/pixelflinger2_interface.h | 65 +++--- libMesa.project | 7 +- src/glsl/builtin_function.cpp | 5 +- src/glsl/glsl_parser_extras.cpp | 2 +- src/glsl/ir_to_llvm.cpp | 6 +- src/glsl/linker.cpp | 11 +- src/mesa/main/mtypes.h | 50 ++-- src/mesa/main/shaderobj.c | 44 ++++ src/mesa/main/shaderobj.h | 169 +++++++------- src/pixelflinger2/pixelflinger2.cpp | 22 +- src/pixelflinger2/pixelflinger2.h | 1 - src/pixelflinger2/raster.cpp | 4 +- src/pixelflinger2/shader.cpp | 297 ++++++++++-------------- test/Android.mk | 3 + test/cmain.c | 22 +- test/egl.cpp | 19 -- test/main.cpp | 162 ++++++++++++- test/mesa.project | 10 +- 19 files changed, 517 insertions(+), 383 deletions(-) create mode 100644 src/mesa/main/shaderobj.c diff --git a/Android.mk b/Android.mk index 929e42c..31e316f 100644 --- a/Android.mk +++ b/Android.mk @@ -101,6 +101,7 @@ libMesa_SRC_FILES := \ src/glsl/strtod.c \ src/glsl/ir_to_llvm.cpp \ src/glsl/ir_to_llvm_helper.cpp \ + src/mesa/main/shaderobj.c \ src/mesa/program/hash_table.c \ src/mesa/program/prog_parameter.cpp \ src/mesa/program/symbol_table.c \ diff --git a/include/pixelflinger2/pixelflinger2_interface.h b/include/pixelflinger2/pixelflinger2_interface.h index 3fa26b2..a141f36 100644 --- a/include/pixelflinger2/pixelflinger2_interface.h +++ b/include/pixelflinger2/pixelflinger2_interface.h @@ -25,8 +25,6 @@ typedef struct gl_shader gl_shader_t; typedef struct gl_shader_program gl_shader_program_t; -typedef struct gl_context gl_context_t; -typedef struct GGLContext GGLContext_t; typedef struct VertexInput { Vector4 attributes[GGL_MAXVERTEXATTRIBS]; // vert input @@ -73,17 +71,18 @@ typedef struct GGLTexture { void * levels; // the following affects vs/fs jit; must fit in byte; size used in GetShaderKey -unsigned wrapS : + enum GGLTextureWrap { + GGL_REPEAT = 0, GGL_CLAMP_TO_EDGE = 1, GGL_MIRRORED_REPEAT = 2 +} wrapS : 2, wrapT : - 2; // GL_REPEAT = 0, GL_CLAMP_TO_EDGE = 1, GL_MIRRORED_REPEAT = 2 - - // GL_NEAREST = 0, GL_LINEAR, GL_NEAREST_MIPMAP_NEAREST = 2, - // GL_LINEAR_MIPMAP_NEAREST, GL_NEAREST_MIPMAP_LINEAR, GL_LINEAR_MIPMAP_LINEAR = 5 -unsigned minFilter : - 3; - -unsigned magFilter : - 1; // GL_NEAREST = 0, GL_LINEAR + 2; + + enum GGLTextureMinFilter { + GGL_NEAREST = 0, GGL_LINEAR, /*GGL_NEAREST_MIPMAP_NEAREST = 2, + GGL_LINEAR_MIPMAP_NEAREST, GGL_NEAREST_MIPMAP_LINEAR, GGL_LINEAR_MIPMAP_LINEAR = 5*/ +} minFilter : +1, magFilter : + 1; // only GGL_NEAREST and GGL_LINEAR } GGLTexture_t; typedef struct GGLStencilState { @@ -117,21 +116,25 @@ unsigned depthFunc : typedef struct GGLBlendState { // all values affect scanline jit unsigned char color[4]; // rgba[0,255] -unsigned scf : + // value = 0,1 | GLenum - GL_SRC_COLOR + 2 | GLenum - GL_CONSTANT_COLOR + 11 + enum GGLBlendFactor { + GGL_ZERO = 0, GGL_ONE, GGL_SRC_COLOR = 2, GGL_ONE_MINUS_SRC_COLOR, GGL_SRC_ALPHA, GGL_ONE_MINUS_SRC_ALPHA, + GGL_DST_ALPHA, GGL_ONE_MINUS_DST_ALPHA, GGL_DST_COLOR, GGL_ONE_MINUS_DST_COLOR, + GGL_SRC_ALPHA_SATURATE, GGL_CONSTANT_COLOR = 11, GGL_ONE_MINUS_CONSTANT_COLOR, + GGL_CONSTANT_ALPHA, GGL_ONE_MINUS_CONSTANT_ALPHA +} scf : 4, saf : 4, dcf : 4, daf : - 4; // GL_ZERO = 0, GL_ONE, GL_SRC_COLOR = 2, - // GL_ONE_MINUS_SRC_COLOR, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, - // GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA, GL_DST_COLOR, GL_ONE_MINUS_DST_COLOR, - // GL_SRC_ALPHA_SATURATE, GL_CONSTANT_COLOR = 11, GL_ONE_MINUS_CONSTANT_COLOR, - // GL_CONSTANT_ALPHA, GL_ONE_MINUS_CONSTANT_ALPHA; - // value = 0,1 | GLenum - GL_SRC_COLOR + 2 | GLenum - GL_CONSTANT_COLOR + 11 + 4; -unsigned ce : + //value = GLenum - GL_FUNC_ADD + enum GGLBlendFunc { + GGL_FUNC_ADD = 0, GGL_FUNC_SUBTRACT = 4, + GGL_FUNC_REVERSE_SUBTRACT = 5 +} ce : 3, ae : - 3; // GL_FUNC_ADD = 0, GL_FUNC_SUBTRACT = 4, - // GL_FUNC_REVERSE_SUBTRACT = 5; value = GLenum - GL_FUNC_ADD + 3; unsigned enable : 1; @@ -217,7 +220,7 @@ struct GGLInterface { // creates empty shader gl_shader_t * (* ShaderCreate)(const GGLInterface_t * iface, GLenum type); - // compiles a shader given glsl; returns GL_TRUE on success; glsl only used during call; use infoLog to retrieve status + // compiles a shader given glsl; returns GL_TRUE on success; glsl only used during call GLboolean (* ShaderCompile)(const GGLInterface_t * iface, gl_shader_t * shader, const char * glsl, const char ** infoLog); @@ -227,14 +230,15 @@ struct GGLInterface { gl_shader_program_t * (* ShaderProgramCreate)(const GGLInterface_t * iface); // attaches a shader to program - void (* ShaderAttach)(const GGLInterface_t * iface, gl_shader_program_t * program, gl_shader_t * shader); + void (* ShaderAttach)(const GGLInterface_t * iface, gl_shader_program_t * program, + gl_shader_t * shader); // detaches a shader from program - void (* ShaderDetach)(const GGLInterface_t * iface, gl_shader_program_t * program, gl_shader_t * shader); + void (* ShaderDetach)(const GGLInterface_t * iface, gl_shader_program_t * program, + gl_shader_t * shader); // duplicates shaders to program, and links varyings / attributes - GLboolean (* ShaderProgramLink)(const GGLInterface_t * iface, gl_shader_program_t * program, - const char ** infoLog); + GLboolean (* ShaderProgramLink)(gl_shader_program_t * program, const char ** infoLog); // frees program void (* ShaderProgramDelete)(GGLInterface_t * iface, gl_shader_program_t * program); @@ -279,7 +283,7 @@ extern "C" gl_shader_t * GGLShaderCreate(GLenum type); // compiles a shader given glsl; returns GL_TRUE on success; glsl only used during call; use infoLog to retrieve status - GLboolean GGLShaderCompile(const gl_context_t * glCtx, gl_shader_t * shader, const char * glsl, const char ** infoLog); + GLboolean GGLShaderCompile(gl_shader_t * shader, const char * glsl, const char ** infoLog); void GGLShaderDelete(gl_shader_t * shader); @@ -293,12 +297,13 @@ extern "C" unsigned GGLShaderDetach(gl_shader_program_t * program, gl_shader_t * shader); // duplicates shaders to program, and links varyings / attributes; - GLboolean GGLShaderProgramLink(gl_context_t * glCtx, gl_shader_program_t * program, const char ** infoLog); + GLboolean GGLShaderProgramLink(gl_shader_program_t * program, const char ** infoLog); + // frees program void GGLShaderProgramDelete(gl_shader_program_t * program); // LLVM JIT and set as active program, also call after gglState change to re-JIT - void GGLShaderUse(const GGLContext_t * gglCtx /*nullable*/, void * llvmCtx, const GGLState_t * gglState, gl_shader_program_t * program); + void GGLShaderUse(void * llvmCtx, const GGLState_t * gglState, gl_shader_program_t * program); // bind attribute location before linking void GGLShaderAttributeBind(const gl_shader_program_t * program, diff --git a/libMesa.project b/libMesa.project index 08a7dd4..4443805 100644 --- a/libMesa.project +++ b/libMesa.project @@ -58,6 +58,7 @@ + @@ -219,9 +220,11 @@ + + - + @@ -315,6 +318,4 @@ - - diff --git a/src/glsl/builtin_function.cpp b/src/glsl/builtin_function.cpp index 9a5e001..1bfca3f 100644 --- a/src/glsl/builtin_function.cpp +++ b/src/glsl/builtin_function.cpp @@ -23,15 +23,12 @@ */ #include -#include "main/core.h" /* for struct gl_shader */ +#include "main/shaderobj.h" /* for struct gl_shader */ #include "glsl_parser_extras.h" #include "ir_reader.h" #include "program.h" #include "ast.h" -extern "C" struct gl_shader * -_mesa_new_shader(struct gl_context *ctx, GLuint name, GLenum type); - gl_shader * read_builtins(void * mem_ctx, GLenum target, const char *protos, const char **functions, unsigned count) { diff --git a/src/glsl/glsl_parser_extras.cpp b/src/glsl/glsl_parser_extras.cpp index 7c851ca..d9f52da 100644 --- a/src/glsl/glsl_parser_extras.cpp +++ b/src/glsl/glsl_parser_extras.cpp @@ -59,7 +59,7 @@ _mesa_glsl_parse_state::_mesa_glsl_parse_state(const struct gl_context *ctx, /* OpenGL ES 2.0 has different defaults from desktop GL. */ if (ctx->API == API_OPENGLES2) { - this->language_version = 100; + this->language_version = 120; this->es_shader = true; this->ARB_texture_rectangle_enable = false; } diff --git a/src/glsl/ir_to_llvm.cpp b/src/glsl/ir_to_llvm.cpp index 0641569..5c8b2ff 100644 --- a/src/glsl/ir_to_llvm.cpp +++ b/src/glsl/ir_to_llvm.cpp @@ -914,19 +914,17 @@ public: sampler = deref->variable_referenced(); else if(ir_dereference_array* deref = ir->sampler->as_dereference_array()) { - result = llvm::Constant::getNullValue(llvm::VectorType::get(bld.getFloatTy(), 4)); + assert(0); // not implemented return; - assert(0); deref->array_index; deref->array; } else if(ir->sampler->as_dereference()) { - assert(0); + assert(0); // not implemented ir_dereference_record* deref = (ir_dereference_record*)ir->sampler; int idx = deref->record->type->field_index(deref->field); assert(idx >= 0); - //return bld.CreateConstInBoundsGEP2_32(llvm_pointer(deref->record), 0, idx); } else assert(0); diff --git a/src/glsl/linker.cpp b/src/glsl/linker.cpp index 0b6a125..e8f1497 100644 --- a/src/glsl/linker.cpp +++ b/src/glsl/linker.cpp @@ -82,11 +82,7 @@ extern "C" { #include "linker.h" #include "ir_optimization.h" -extern "C" { #include "main/shaderobj.h" -} - -extern "C" void _mesa_delete_shader(gl_context * ctx, gl_shader * shader); /** * Visitor that determines whether or not a variable is ever written. @@ -763,7 +759,7 @@ get_main_function_signature(gl_shader *sh) */ static struct gl_shader * link_intrastage_shaders(void *mem_ctx, - struct gl_context *ctx, + const struct gl_context *ctx, struct gl_shader_program *prog, struct gl_shader **shader_list, unsigned num_shaders) @@ -837,8 +833,7 @@ link_intrastage_shaders(void *mem_ctx, return NULL; } - gl_shader *linked = _mesa_new_shader(ctx, 0, main->Type); - hieralloc_steal(prog, linked); + gl_shader *linked = _mesa_new_shader(prog, 0, main->Type); linked->ir = new(linked) exec_list; clone_ir_list(mem_ctx, linked->ir, main->ir); @@ -1533,7 +1528,7 @@ assign_varying_locations(struct gl_shader_program *prog, void -link_shaders(struct gl_context *ctx, struct gl_shader_program *prog) +link_shaders(const struct gl_context *ctx, struct gl_shader_program *prog) { //void *mem_ctx = hieralloc_init("temporary linker context"); void * mem_ctx = prog; // need linked & cloned ir to persist diff --git a/src/mesa/main/mtypes.h b/src/mesa/main/mtypes.h index 8dd73d1..5364b02 100644 --- a/src/mesa/main/mtypes.h +++ b/src/mesa/main/mtypes.h @@ -2628,32 +2628,32 @@ struct gl_constants GLuint MaxVarying; /**< Number of float[4] varying parameters */ - GLuint GLSLVersion; /**< GLSL version supported (ex: 120 = 1.20) */ +// GLuint GLSLVersion; /**< GLSL version supported (ex: 120 = 1.20) */ - /** Which texture units support GL_ATI_envmap_bumpmap as targets */ - GLbitfield SupportedBumpUnits; - - /** - * Maximum amount of time, measured in nanseconds, that the server can wait. - */ - GLuint64 MaxServerWaitTimeout; - - /** GL_EXT_provoking_vertex */ - GLboolean QuadsFollowProvokingVertexConvention; - - /** OpenGL version 3.0 */ - GLbitfield ContextFlags; /**< Ex: GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT */ - - /** OpenGL version 3.2 */ - GLbitfield ProfileMask; /**< Mask of CONTEXT_x_PROFILE_BIT */ - - /** GL_EXT_transform_feedback */ - GLuint MaxTransformFeedbackSeparateAttribs; - GLuint MaxTransformFeedbackSeparateComponents; - GLuint MaxTransformFeedbackInterleavedComponents; - - /** GL_EXT_gpu_shader4 */ - GLint MinProgramTexelOffset, MaxProgramTexelOffset; +// /** Which texture units support GL_ATI_envmap_bumpmap as targets */ +// GLbitfield SupportedBumpUnits; +// +// /** +// * Maximum amount of time, measured in nanseconds, that the server can wait. +// */ +// GLuint64 MaxServerWaitTimeout; +// +// /** GL_EXT_provoking_vertex */ +// GLboolean QuadsFollowProvokingVertexConvention; +// +// /** OpenGL version 3.0 */ +// GLbitfield ContextFlags; /**< Ex: GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT */ +// +// /** OpenGL version 3.2 */ +// GLbitfield ProfileMask; /**< Mask of CONTEXT_x_PROFILE_BIT */ +// +// /** GL_EXT_transform_feedback */ +// GLuint MaxTransformFeedbackSeparateAttribs; +// GLuint MaxTransformFeedbackSeparateComponents; +// GLuint MaxTransformFeedbackInterleavedComponents; +// +// /** GL_EXT_gpu_shader4 */ +// GLint MinProgramTexelOffset, MaxProgramTexelOffset; }; diff --git a/src/mesa/main/shaderobj.c b/src/mesa/main/shaderobj.c new file mode 100644 index 0000000..4fc572c --- /dev/null +++ b/src/mesa/main/shaderobj.c @@ -0,0 +1,44 @@ +#include +#include + +#include + +#include + +void _mesa_reference_shader(const void * ctx, struct gl_shader **ptr, + struct gl_shader *sh) +{ + *ptr = sh; +} + +static struct gl_shader * (watches[20]) = {0}; +static unsigned watch = 0; + +struct gl_shader * _mesa_new_shader(const void * ctx, GLuint name, GLenum type) +{ + assert(type == GL_FRAGMENT_SHADER || type == GL_VERTEX_SHADER); + struct gl_shader * shader = (struct gl_shader *)_hieralloc_zero(ctx, sizeof(struct gl_shader), "zr:gl_shader"); + if (shader) { + shader->Type = type; + shader->Name = name; + shader->RefCount = 1; + } + if (!ctx) + watches[watch++] = shader; + return shader; +} + +void _mesa_delete_shader(const void * ctx, struct gl_shader *shader) +{ + if (!shader) + return; + if (shader->RefCount > 1) { + shader->DeletePending = GL_TRUE; + return; + } + unsigned i = 0; + for (i = 0; i < watch; i++) + if (watches[i] == shader) + watches[i] = watches[--watch]; + hieralloc_free(shader); +} \ No newline at end of file diff --git a/src/mesa/main/shaderobj.h b/src/mesa/main/shaderobj.h index de7c998..683b70b 100644 --- a/src/mesa/main/shaderobj.h +++ b/src/mesa/main/shaderobj.h @@ -39,95 +39,98 @@ extern "C" { * Internal functions */ +//extern void +//_mesa_init_shader_state(struct gl_context * ctx); +// +//extern void +//_mesa_free_shader_state(struct gl_context *ctx); +// +// extern void -_mesa_init_shader_state(struct gl_context * ctx); - -extern void -_mesa_free_shader_state(struct gl_context *ctx); - - -extern void -_mesa_reference_shader(struct gl_context *ctx, struct gl_shader **ptr, +_mesa_reference_shader(const void * ctx, struct gl_shader **ptr, struct gl_shader *sh); +// +//extern struct gl_shader * +//_mesa_lookup_shader(struct gl_context *ctx, GLuint name); +// +//extern struct gl_shader * +//_mesa_lookup_shader_err(struct gl_context *ctx, GLuint name, const char *caller); +// +// +// +//extern void +//_mesa_reference_shader_program(struct gl_context *ctx, +// struct gl_shader_program **ptr, +// struct gl_shader_program *shProg); +//extern void +//_mesa_init_shader(struct gl_context *ctx, struct gl_shader *shader); extern struct gl_shader * -_mesa_lookup_shader(struct gl_context *ctx, GLuint name); +_mesa_new_shader(const void * ctx, GLuint name, GLenum type); extern struct gl_shader * -_mesa_lookup_shader_err(struct gl_context *ctx, GLuint name, const char *caller); - - - -extern void -_mesa_reference_shader_program(struct gl_context *ctx, - struct gl_shader_program **ptr, - struct gl_shader_program *shProg); -extern void -_mesa_init_shader(struct gl_context *ctx, struct gl_shader *shader); - -extern struct gl_shader * -_mesa_new_shader(struct gl_context *ctx, GLuint name, GLenum type); - -extern void -_mesa_init_shader_program(struct gl_context *ctx, struct gl_shader_program *prog); - -extern struct gl_shader_program * -_mesa_lookup_shader_program(struct gl_context *ctx, GLuint name); - -extern struct gl_shader_program * -_mesa_lookup_shader_program_err(struct gl_context *ctx, GLuint name, - const char *caller); - -extern void -_mesa_clear_shader_program_data(struct gl_context *ctx, - struct gl_shader_program *shProg); - -extern void -_mesa_free_shader_program_data(struct gl_context *ctx, - struct gl_shader_program *shProg); - - - -extern void -_mesa_init_shader_object_functions(struct dd_function_table *driver); - -extern void -_mesa_init_shader_state(struct gl_context *ctx); - -extern void -_mesa_free_shader_state(struct gl_context *ctx); - - -static INLINE gl_shader_type -_mesa_shader_type_to_index(GLenum v) -{ - switch (v) { - case GL_VERTEX_SHADER: - return MESA_SHADER_VERTEX; - case GL_FRAGMENT_SHADER: - return MESA_SHADER_FRAGMENT; - case GL_GEOMETRY_SHADER: - return MESA_SHADER_GEOMETRY; - default: - ASSERT(0 && "bad value in _mesa_shader_type_to_index()"); - return MESA_SHADER_TYPES; - } -} - - -static INLINE GLenum -_mesa_shader_index_to_type(GLuint i) -{ - static const GLenum enums[MESA_SHADER_TYPES] = { - GL_VERTEX_SHADER, - GL_FRAGMENT_SHADER, - GL_GEOMETRY_SHADER , - }; - if (i >= MESA_SHADER_TYPES) - return 0; - else - return enums[i]; -} +_mesa_delete_shader(const void * ctx, struct gl_shader * shader); + +//extern void +//_mesa_init_shader_program(struct gl_context *ctx, struct gl_shader_program *prog); +// +//extern struct gl_shader_program * +//_mesa_lookup_shader_program(struct gl_context *ctx, GLuint name); +// +//extern struct gl_shader_program * +//_mesa_lookup_shader_program_err(struct gl_context *ctx, GLuint name, +// const char *caller); +// +//extern void +//_mesa_clear_shader_program_data(struct gl_context *ctx, +// struct gl_shader_program *shProg); +// +//extern void +//_mesa_free_shader_program_data(struct gl_context *ctx, +// struct gl_shader_program *shProg); +// +// +// +//extern void +//_mesa_init_shader_object_functions(struct dd_function_table *driver); +// +//extern void +//_mesa_init_shader_state(struct gl_context *ctx); +// +//extern void +//_mesa_free_shader_state(struct gl_context *ctx); + + +//static INLINE gl_shader_type +//_mesa_shader_type_to_index(GLenum v) +//{ +// switch (v) { +// case GL_VERTEX_SHADER: +// return MESA_SHADER_VERTEX; +// case GL_FRAGMENT_SHADER: +// return MESA_SHADER_FRAGMENT; +// case GL_GEOMETRY_SHADER: +// return MESA_SHADER_GEOMETRY; +// default: +// ASSERT(0 && "bad value in _mesa_shader_type_to_index()"); +// return MESA_SHADER_TYPES; +// } +//} +// +// +//static INLINE GLenum +//_mesa_shader_index_to_type(GLuint i) +//{ +// static const GLenum enums[MESA_SHADER_TYPES] = { +// GL_VERTEX_SHADER, +// GL_FRAGMENT_SHADER, +// GL_GEOMETRY_SHADER , +// }; +// if (i >= MESA_SHADER_TYPES) +// return 0; +// else +// return enums[i]; +//} #ifdef __cplusplus diff --git a/src/pixelflinger2/pixelflinger2.cpp b/src/pixelflinger2/pixelflinger2.cpp index 2eb419d..eee0d95 100644 --- a/src/pixelflinger2/pixelflinger2.cpp +++ b/src/pixelflinger2/pixelflinger2.cpp @@ -83,8 +83,8 @@ static void BlendEquationSeparate(GGLInterface * iface, GLenum modeRGB, GLenum m if (GL_FUNC_ADD != modeRGB && (GL_FUNC_SUBTRACT > modeRGB || GL_FUNC_REVERSE_SUBTRACT < modeRGB)) return gglError(GL_INVALID_ENUM); - ctx->state.blendState.ce = modeRGB - GL_FUNC_ADD; - ctx->state.blendState.ae = modeAlpha - GL_FUNC_ADD; + ctx->state.blendState.ce = (GGLBlendState::GGLBlendFunc)(modeRGB - GL_FUNC_ADD); + ctx->state.blendState.ae = (GGLBlendState::GGLBlendFunc)(modeAlpha - GL_FUNC_ADD); SetShaderVerifyFunctions(iface); } @@ -111,21 +111,21 @@ static void BlendFuncSeparate(GGLInterface * iface, GLenum srcRGB, GLenum dstRGB srcAlpha = GL_ONE; // in c++ it's templated function for color and alpha, // so it requires setting srcAlpha to GL_ONE to run template again only for alpha - ctx->state.blendState.scf = srcRGB <= GL_ONE ? srcRGB : + ctx->state.blendState.scf = (GGLBlendState::GGLBlendFactor)(srcRGB <= GL_ONE ? srcRGB : (srcRGB <= GL_SRC_ALPHA_SATURATE ? srcRGB - GL_SRC_COLOR + 2 - : srcRGB - GL_CONSTANT_COLOR + 11); + : srcRGB - GL_CONSTANT_COLOR + 11)); - ctx->state.blendState.saf = srcAlpha <= GL_ONE ? srcAlpha : + ctx->state.blendState.saf = (GGLBlendState::GGLBlendFactor)(srcAlpha <= GL_ONE ? srcAlpha : (srcAlpha <= GL_SRC_ALPHA_SATURATE ? srcAlpha - GL_SRC_COLOR + 2 - : srcAlpha - GL_CONSTANT_COLOR + 11); + : srcAlpha - GL_CONSTANT_COLOR + 11)); - ctx->state.blendState.dcf = dstRGB <= GL_ONE ? dstRGB : + ctx->state.blendState.dcf = (GGLBlendState::GGLBlendFactor)(dstRGB <= GL_ONE ? dstRGB : (dstRGB <= GL_SRC_ALPHA_SATURATE ? dstRGB - GL_SRC_COLOR + 2 - : dstRGB - GL_CONSTANT_COLOR + 11); + : dstRGB - GL_CONSTANT_COLOR + 11)); - ctx->state.blendState.daf = dstAlpha <= GL_ONE ? dstAlpha : + ctx->state.blendState.daf = (GGLBlendState::GGLBlendFactor)(dstAlpha <= GL_ONE ? dstAlpha : (dstAlpha <= GL_SRC_ALPHA_SATURATE ? dstAlpha - GL_SRC_COLOR + 2 - : dstAlpha - GL_CONSTANT_COLOR + 11); + : dstAlpha - GL_CONSTANT_COLOR + 11)); SetShaderVerifyFunctions(iface); @@ -225,8 +225,6 @@ void DestroyGGLInterface(GGLInterface * iface) DestroyShaderFunctions(iface); - ctx->glCtx = NULL; - free(ctx); #if USE_LLVM_TEXTURE_SAMPLER diff --git a/src/pixelflinger2/pixelflinger2.h b/src/pixelflinger2/pixelflinger2.h index 007954a..3d68d13 100644 --- a/src/pixelflinger2/pixelflinger2.h +++ b/src/pixelflinger2/pixelflinger2.h @@ -60,7 +60,6 @@ struct GGLContext { GGLSurface depthSurface; GGLSurface stencilSurface; - struct gl_context * glCtx; // hieralloc; mesa constants and others used for shader compiling and executing llvm::LLVMContext * llvmCtx; struct { diff --git a/src/pixelflinger2/raster.cpp b/src/pixelflinger2/raster.cpp index c2db172..74fdc19 100644 --- a/src/pixelflinger2/raster.cpp +++ b/src/pixelflinger2/raster.cpp @@ -53,8 +53,8 @@ static inline void InterpolateVertex(const VertexOutput * a, const VertexOutput } -void GGLProcessVertex(const gl_shader_program * program, const VertexInput_t * input, - VertexOutput_t * output, const float (*constants)[4]) +void GGLProcessVertex(const gl_shader_program * program, const VertexInput * input, + VertexOutput * output, const float (*constants)[4]) { ShaderFunction_t function = (ShaderFunction_t)program->_LinkedShaders[MESA_SHADER_VERTEX]->function; function(input, output, constants); diff --git a/src/pixelflinger2/shader.cpp b/src/pixelflinger2/shader.cpp index 87af237..2f6be4b 100644 --- a/src/pixelflinger2/shader.cpp +++ b/src/pixelflinger2/shader.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2010 The Android Open Source Project + * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -27,12 +27,65 @@ #include "src/talloc/hieralloc.h" -#include "src/mesa/main/mtypes.h" +#include "src/mesa/main/shaderobj.h" #include "src/mesa/program/prog_parameter.h" #include "src/mesa/program/prog_uniform.h" #include "src/glsl/glsl_types.h" #include "src/glsl/ir_to_llvm.h" +static void InitializeGLContext(struct gl_context *ctx) +{ + memset(ctx, 0, sizeof(*ctx)); + ctx->API = API_OPENGLES2; + ctx->Extensions.ARB_draw_buffers = GL_TRUE; + ctx->Extensions.ARB_fragment_coord_conventions = GL_TRUE; + ctx->Extensions.EXT_texture_array = GL_TRUE; + ctx->Extensions.NV_texture_rectangle = GL_TRUE; + + /* 1.10 minimums. */ + ctx->Const.MaxLights = 8; + ctx->Const.MaxClipPlanes = 8; + ctx->Const.MaxTextureUnits = 2; + + /* More than the 1.10 minimum to appease parser tests taken from + * apps that (hopefully) already checked the number of coords. + */ + ctx->Const.MaxTextureCoordUnits = 4; + + ctx->Const.VertexProgram.MaxAttribs = 16; + ctx->Const.VertexProgram.MaxUniformComponents = 512; + ctx->Const.MaxVarying = 8; + ctx->Const.MaxVertexTextureImageUnits = 0; + ctx->Const.MaxCombinedTextureImageUnits = 2; + ctx->Const.MaxTextureImageUnits = 2; + ctx->Const.FragmentProgram.MaxUniformComponents = 64; + + ctx->Const.MaxDrawBuffers = 2; +} + +static const struct GLContext { + const gl_context * ctx; + GLContext() { + ctx = hieralloc_zero(NULL, gl_context); +// ctx = (const gl_context*)calloc(1,sizeof(gl_context)); + InitializeGLContext(const_cast(ctx)); + } + ~GLContext() { + _mesa_glsl_release_types(); // TODO: find when to release to minize memory + _mesa_glsl_release_functions(); // the IR has pointers to types + hieralloc_free(const_cast(ctx)); +// free(const_cast(ctx)); + ctx = NULL; + } +} glContext; + +void GLContextDctr() +{ + _mesa_glsl_release_types(); // TODO: find when to release to minize memory + _mesa_glsl_release_functions(); + //glContext.~GLContext(); +} + struct ShaderKey { struct ScanLineKey { GGLStencilState frontStencil, backStencil; @@ -65,46 +118,10 @@ struct Executable { // codegen info bool do_mat_op_to_vec(exec_list *instructions); -extern void link_shaders(struct gl_context *ctx, struct gl_shader_program *prog); +extern void link_shaders(const struct gl_context *ctx, struct gl_shader_program *prog); extern "C" void compile_shader(const struct gl_context *ctx, struct gl_shader *shader); -extern "C" void _mesa_reference_shader(struct gl_context *ctx, struct gl_shader **ptr, - struct gl_shader *sh) -{ - *ptr = sh; -} - -extern "C" gl_shader * _mesa_new_shader(struct gl_context *ctx, GLuint name, GLenum type) -{ - struct gl_shader *shader; - assert(type == GL_FRAGMENT_SHADER || type == GL_VERTEX_SHADER); - shader = hieralloc_zero(ctx, struct gl_shader); - if (shader) { - shader->Type = type; - shader->Name = name; - shader->RefCount = 1; - } - return shader; -} - -extern "C" void _mesa_delete_shader(struct gl_context *ctx, struct gl_shader *shader) -{ - if (!shader) - return; - if (shader->RefCount > 1) { - shader->DeletePending = true; - return; - } - if (shader->executable) { - for (std::map::iterator it=shader->executable->instances.begin(); - it != shader->executable->instances.end(); it++) - (*it).second->~Instance(); - shader->executable->instances.~map(); - } - hieralloc_free(shader); -} - gl_shader * GGLShaderCreate(GLenum type) { return _mesa_new_shader(NULL, 0, type); @@ -117,18 +134,17 @@ static gl_shader * ShaderCreate(const GGLInterface * iface, GLenum type) gglError(GL_INVALID_ENUM); return NULL; } - gl_shader * shader = _mesa_new_shader(ctx->glCtx, 0, type); + gl_shader * shader = _mesa_new_shader(NULL, 0, type); if (!shader) gglError(GL_OUT_OF_MEMORY); assert(1 == shader->RefCount); return shader; } -GLboolean GGLShaderCompile(const gl_context * glCtx, gl_shader * shader, - const char * glsl, const char ** infoLog) +GLboolean GGLShaderCompile(gl_shader * shader, const char * glsl, const char ** infoLog) { shader->Source = glsl; - compile_shader(glCtx, shader); + compile_shader(glContext.ctx, shader); shader->Source = NULL; if (infoLog) *infoLog = shader->InfoLog; @@ -143,18 +159,23 @@ static GLboolean ShaderCompile(const GGLInterface * iface, gl_shader * shader, gglError(GL_INVALID_VALUE); return GL_FALSE; } - return GGLShaderCompile(ctx->glCtx, shader, glsl, infoLog); + return GGLShaderCompile(shader, glsl, infoLog); } void GGLShaderDelete(gl_shader * shader) { + if (shader && shader->executable) { + for (std::map::iterator it=shader->executable->instances.begin(); + it != shader->executable->instances.end(); it++) + (*it).second->~Instance(); + shader->executable->instances.~map(); + } _mesa_delete_shader(NULL, shader); } static void ShaderDelete(const GGLInterface * iface, gl_shader * shader) { - GGL_GET_CONST_CONTEXT(ctx, iface); - _mesa_delete_shader(ctx->glCtx, shader); + GGLShaderDelete(shader); } gl_shader_program * GGLShaderProgramCreate() @@ -178,23 +199,9 @@ gl_shader_program * GGLShaderProgramCreate() static gl_shader_program * ShaderProgramCreate(const GGLInterface * iface) { GGL_GET_CONST_CONTEXT(ctx, iface); - gl_shader_program * program = hieralloc_zero(ctx->glCtx, struct gl_shader_program); - if (!program) { - gglError(GL_OUT_OF_MEMORY); - return NULL; - } - program->Attributes = hieralloc_zero(program, gl_program_parameter_list); - if (!program->Attributes) { - hieralloc_free(program); - gglError(GL_OUT_OF_MEMORY); - return NULL; - } - program->Varying = hieralloc_zero(program, gl_program_parameter_list); - if (!program->Varying) { - hieralloc_free(program); - gglError(GL_OUT_OF_MEMORY); - return NULL; - } + gl_shader_program * program = GGLShaderProgramCreate(); + if (!program) + gglError(GL_OUT_OF_MEMORY); return program; } @@ -224,32 +231,9 @@ static void ShaderAttach(const GGLInterface * iface, gl_shader_program * program gglError(error); } -unsigned GGLShaderDetach(gl_shader_program * program, gl_shader * shader) +GLboolean GGLShaderProgramLink(gl_shader_program * program, const char ** infoLog) { - for (unsigned i = 0; i < program->NumShaders; i++) - if (program->Shaders[i] == shader) { - program->NumShaders--; - program->Shaders[i] = program->Shaders[program->NumShaders]; - shader->RefCount--; - if (1 == shader->RefCount && shader->DeletePending) - GGLShaderDelete(shader); - return GL_NO_ERROR; - } - return (GL_INVALID_OPERATION); -} - -static void ShaderDetach(const GGLInterface * iface, gl_shader_program * program, - gl_shader * shader) -{ - unsigned error = GGLShaderDetach(program, shader); - if (GL_NO_ERROR != error) - gglError(error); -} - -GLboolean GGLShaderProgramLink(gl_context * glCtx, gl_shader_program * program, - const char ** infoLog) -{ - link_shaders(glCtx, program); + link_shaders(glContext.ctx, program); if (infoLog) *infoLog = program->InfoLog; if (!program->LinkStatus) @@ -268,11 +252,10 @@ GLboolean GGLShaderProgramLink(gl_context * glCtx, gl_shader_program * program, } return program->LinkStatus; } -static GLboolean ShaderProgramLink(const GGLInterface * iface, gl_shader_program * program, - const char ** infoLog) + +static GLboolean ShaderProgramLink(gl_shader_program * program, const char ** infoLog) { - GGL_GET_CONST_CONTEXT(ctx, iface); - return GGLShaderProgramLink(ctx->glCtx, program, infoLog); + return GGLShaderProgramLink(program, infoLog); } static void GetShaderKey(const GGLState * ctx, const gl_shader * shader, ShaderKey * key) @@ -367,32 +350,8 @@ static void* SymbolLookup(void* pContext, const char* name) symbol = (void *)gglCtx->textureState.textureData; else if (!strcmp(_PF2_TEXTURE_DIMENSIONS_NAME_, name)) symbol = (void *)gglCtx->textureState.textureDimensions; - else { - for (unsigned i = 0; i < program->Uniforms->NumUniforms && !symbol; i++) - if (!strcmp(program->Uniforms->Uniforms[i].Name, name)) - symbol = program->ValuesUniform + program->Uniforms->Uniforms[i].Pos; - for (unsigned i = 0; i < program->Attributes->NumParameters && !symbol; i++) - if (!strcmp(program->Attributes->Parameters[i].Name, name)) { - assert(program->Attributes->Parameters[i].Location - < sizeof(VertexInput) / sizeof(float[4])); - symbol = program->ValuesVertexInput + program->Attributes->Parameters[i].Location; - } - for (unsigned i = 0; i < program->Varying->NumParameters && !symbol; i++) - if (!strcmp(program->Varying->Parameters[i].Name, name)) { - int index = -1; - if (GL_VERTEX_SHADER == shader->Type) - index = program->Varying->Parameters[i].BindLocation; - else if (GL_FRAGMENT_SHADER == shader->Type) - index = program->Varying->Parameters[i].Location; - else - assert(0); - assert(index >= 0); - assert(index < sizeof(VertexOutput) / sizeof(float[4])); - symbol = program->ValuesVertexOutput + index; - } - assert(symbol >= program->ValuesVertexInput && - symbol < (char *)program->ValuesUniform + 16 * program->Uniforms->Slots - 3); - }; + else // attributes, varyings and uniforms are mapped to locations in pointers + assert(0); } printf("symbolLookup '%s'=%p \n", name, symbol); assert(symbol); @@ -432,12 +391,13 @@ static void CodeGen(Instance * instance, const char * mainName, gl_shader * shad void GenerateScanLine(const GGLState * gglCtx, const gl_shader_program * program, llvm::Module * mod, const char * shaderName, const char * scanlineName); -void GGLShaderUse(const GGLContext * gglCtx, void * llvmCtx, const GGLState * gglState, gl_shader_program * program) +void GGLShaderUse(void * llvmCtx, const GGLState * gglState, gl_shader_program * program) { for (unsigned i = 0; i < MESA_SHADER_TYPES; i++) { if (!program->_LinkedShaders[i]) continue; gl_shader * shader = program->_LinkedShaders[i]; + shader->function = NULL; if (!shader->executable) { shader->executable = hieralloc_zero(shader, Executable); shader->executable->instances = std::map(); @@ -457,7 +417,7 @@ void GGLShaderUse(const GGLContext * gglCtx, void * llvmCtx, const GGLState * gg char mainName [SHADER_KEY_STRING_LEN + 6] = {"main"}; strcat(mainName, shaderName); - do_mat_op_to_vec(shader->ir); + do_mat_op_to_vec(shader->ir); // TODO: move these passes to link? llvm::Module * module = glsl_ir_to_llvm_module(shader->ir, instance->module, gglState, shaderName); if (!module) @@ -478,42 +438,71 @@ void GGLShaderUse(const GGLContext * gglCtx, void * llvmCtx, const GGLState * gg ; shader->function = instance->function; - - if (gglCtx) - if (GL_VERTEX_SHADER == shader->Type) - gglCtx->PickRaster((GGLInterface *)gglCtx); - else if (GL_FRAGMENT_SHADER == shader->Type) - gglCtx->PickScanLine((GGLInterface *)gglCtx); - else - assert(0); } } static void ShaderUse(GGLInterface * iface, gl_shader_program * program) { GGL_GET_CONTEXT(ctx, iface); - assert(program); + // so drawing calls will do nothing until ShaderUse with a program + SetShaderVerifyFunctions(iface); if (!program) { ctx->CurrentProgram = NULL; - // so drawing calls will do nothing until ShaderUse with a program - SetShaderVerifyFunctions(iface); return; } - GGLShaderUse(ctx, ctx->llvmCtx, &ctx->state, program); + GGLShaderUse(ctx->llvmCtx, &ctx->state, program); + for (unsigned i = 0; i < MESA_SHADER_TYPES; i++) { + if (!program->_LinkedShaders[i]) + continue; + if (!program->_LinkedShaders[i]->function) + continue; + if (GL_VERTEX_SHADER == program->_LinkedShaders[i]->Type) + ctx->PickRaster(iface); + else if (GL_FRAGMENT_SHADER == program->_LinkedShaders[i]->Type) + ctx->PickScanLine(iface); + else + assert(0); + } ctx->CurrentProgram = program; } +unsigned GGLShaderDetach(gl_shader_program * program, gl_shader * shader) +{ + for (unsigned i = 0; i < program->NumShaders; i++) + if (program->Shaders[i] == shader) { + program->NumShaders--; + // just swap end to deleted shader + program->Shaders[i] = program->Shaders[program->NumShaders]; + shader->RefCount--; + if (1 == shader->RefCount && shader->DeletePending) + GGLShaderDelete(shader); + return GL_NO_ERROR; + } + return (GL_INVALID_OPERATION); +} + +static void ShaderDetach(const GGLInterface * iface, gl_shader_program * program, + gl_shader * shader) +{ + unsigned error = GGLShaderDetach(program, shader); + if (GL_NO_ERROR != error) + gglError(error); +} + void GGLShaderProgramDelete(gl_shader_program * program) { for (unsigned i = 0; i < program->NumShaders; i++) { - GGLShaderDelete(program->Shaders[i]); - GGLShaderDetach(program, program->Shaders[i]); + GGLShaderDelete(program->Shaders[i]); // actually just mark for delete + GGLShaderDetach(program, program->Shaders[i]); // detach will delete if ref == 1 + i--; // GGLShaderDetach just swaps end to detached shader } for (unsigned i = 0; i < MESA_SHADER_TYPES; i++) GGLShaderDelete(program->_LinkedShaders[i]); + + hieralloc_free(program); } static void ShaderProgramDelete(GGLInterface * iface, gl_shader_program * program) @@ -521,9 +510,8 @@ static void ShaderProgramDelete(GGLInterface * iface, gl_shader_program * progra GGL_GET_CONTEXT(ctx, iface); if (ctx->CurrentProgram == program) { ctx->CurrentProgram = NULL; - SetShaderVerifyFunctions(const_cast(iface)); + SetShaderVerifyFunctions(iface); } - GGLShaderProgramDelete(program); } @@ -626,7 +614,8 @@ void GGLShaderUniformMatrix(gl_shader_program * program, GLint cols, GLint rows, if (location == -1) return; assert(cols == rows); - int start = location, slots = cols * count; + int start = location; + unsigned slots = cols * count; if (start < 0 || start + slots > program->Uniforms->Slots) return gglError(GL_INVALID_OPERATION); for (unsigned i = 0; i < slots; i++) { @@ -702,42 +691,10 @@ void SetShaderVerifyFunctions(struct GGLInterface * iface) iface->ScanLine = ShaderVerifyScanLine; } -static void InitializeGLContext(struct gl_context *ctx) -{ - memset(ctx, 0, sizeof(*ctx)); - ctx->API = API_OPENGLES2; - ctx->Extensions.ARB_draw_buffers = GL_TRUE; - ctx->Extensions.ARB_fragment_coord_conventions = GL_TRUE; - ctx->Extensions.EXT_texture_array = GL_TRUE; - ctx->Extensions.NV_texture_rectangle = GL_TRUE; - - /* 1.10 minimums. */ - ctx->Const.MaxLights = 8; - ctx->Const.MaxClipPlanes = 8; - ctx->Const.MaxTextureUnits = 2; - - /* More than the 1.10 minimum to appease parser tests taken from - * apps that (hopefully) already checked the number of coords. - */ - ctx->Const.MaxTextureCoordUnits = 4; - - ctx->Const.VertexProgram.MaxAttribs = 16; - ctx->Const.VertexProgram.MaxUniformComponents = 512; - ctx->Const.MaxVarying = 8; - ctx->Const.MaxVertexTextureImageUnits = 0; - ctx->Const.MaxCombinedTextureImageUnits = 2; - ctx->Const.MaxTextureImageUnits = 2; - ctx->Const.FragmentProgram.MaxUniformComponents = 64; - - ctx->Const.MaxDrawBuffers = 2; -} - void InitializeShaderFunctions(struct GGLInterface * iface) { GGL_GET_CONTEXT(ctx, iface); ctx->llvmCtx = new llvm::LLVMContext(); - ctx->glCtx = hieralloc(NULL, gl_context); - InitializeGLContext(ctx->glCtx); iface->ShaderCreate = ShaderCreate; iface->ShaderCompile = ShaderCompile; @@ -763,6 +720,6 @@ void DestroyShaderFunctions(GGLInterface * iface) GGL_GET_CONTEXT(ctx, iface); _mesa_glsl_release_types(); _mesa_glsl_release_functions(); - hieralloc_free(ctx->glCtx); delete ctx->llvmCtx; + ctx->llvmCtx = NULL; } diff --git a/test/Android.mk b/test/Android.mk index 593d163..4776c3d 100644 --- a/test/Android.mk +++ b/test/Android.mk @@ -3,6 +3,7 @@ DEBUG_BUILD := true ifneq ($(TARGET_SIMULATOR),true) LOCAL_PATH := $(call my-dir) +LLVM_ROOT_PATH := external/llvm mesa_SRC_FILES := \ egl.cpp \ @@ -29,6 +30,7 @@ LOCAL_C_INCLUDES := \ $(LOCAL_PATH) \ frameworks/compile/mesa/include +include $(LLVM_ROOT_PATH)/llvm-host-build.mk include $(BUILD_HOST_EXECUTABLE) # Executable for target @@ -51,6 +53,7 @@ LOCAL_C_INCLUDES := \ $(LOCAL_PATH) \ frameworks/compile/mesa/include +include $(LLVM_ROOT_PATH)/llvm-device-build.mk include $(BUILD_EXECUTABLE) endif # TARGET_SIMULATOR != true diff --git a/test/cmain.c b/test/cmain.c index 6271f2e..3ffeaa0 100644 --- a/test/cmain.c +++ b/test/cmain.c @@ -37,7 +37,7 @@ int cmain(int argc, char **argv) " gl_Position = aPosition; \n" " vTexCoord = aTexCoord + uVec4; \n" " vTexColor = texture2D(sampler2d, aTexCoord.zw); \n" - " gl_PointSize = 432.0; \n" + " gl_PointSize = 432; \n" "}"; puts(glsl0); GLboolean compileStatus = ggl->ShaderCompile(ggl, shader0, glsl0, &infoLog); @@ -69,7 +69,7 @@ int cmain(int argc, char **argv) ggl->ShaderAttributeBind(program0, 2, "aTexCoord"); ggl->ShaderAttributeBind(program0, 3, "aPosition"); - GLboolean linkStatus = ggl->ShaderProgramLink(ggl, program0, &infoLog); + GLboolean linkStatus = ggl->ShaderProgramLink(program0, &infoLog); if (!linkStatus) fprintf(stderr, "failed to link program 0, infoLog: \n %s \n", infoLog); assert(linkStatus); @@ -79,7 +79,7 @@ int cmain(int argc, char **argv) unsigned texels0 [] = {0xffffffff, 0x22222222, 0x66666666, 0xffffffff}; GGLTexture_t texture0 = {GL_TEXTURE_2D, GGL_PIXEL_FORMAT_RGBA_8888, 2, 2, 1, // width, height, levelCount - texels0, 1, 2, 1, 1 + texels0, GGL_CLAMP_TO_EDGE, GGL_MIRRORED_REPEAT, GGL_LINEAR, GGL_LINEAR }; // levels, wrapS, wrapT, minFilter, magFilter int sampler2dLoc = ggl->ShaderUniformLocation(program0, "sampler2d"); @@ -122,8 +122,18 @@ int cmain(int argc, char **argv) assert(0); } -// TODO DXL linear filtering needs to be fixed for texcoord outside of [0,1] - v0.attributes[2] = VECTOR4_CTR(0,0, 0.5f, 0.5f); + v0.attributes[2] = VECTOR4_CTR(0,0, 1.5f, 1.5f); + texture0.wrapS = GGL_REPEAT; + texture0.wrapT = GGL_REPEAT; + + sampler2dLoc = ggl->ShaderUniformLocation(program0, "sampler2d"); + if (0 <= sampler2dLoc) { + int samplerUnit = -1; + //ggl->ShaderUniformGetiv(ggl, program0, sampler2dLoc, &samplerUnit); + samplerUnit = sampler2dLoc; + ggl->SetSampler(ggl, samplerUnit, &texture0); + } + ggl->ShaderUse(ggl, program0); ggl->ProcessVertex(ggl, &v0, &vout0); const float filtered = (float)(0xff + 0x22 + 0x66 + 0xff) / (4 * 0xff); if (!ApproximatelyEqual(vout0.varyings[vTexColorIndex], @@ -149,7 +159,7 @@ int cmain(int argc, char **argv) ggl->ClearColor(ggl, 0.1f, 0.1f, 0.1f, 1.0f); ggl->ClearDepthf(ggl, 0.5f); -// TODO DXL scanline and fs test +// TODO DXL test scanline and fs free(colorSurface.data); colorSurface.data = NULL; diff --git a/test/egl.cpp b/test/egl.cpp index 5b55400..f31e30d 100644 --- a/test/egl.cpp +++ b/test/egl.cpp @@ -693,12 +693,6 @@ EGLBoolean egl_window_surface_v2_t::bindDrawSurface(ogles_context_t* gl) //puts("egl_window_surface_v2_t::bindDrawSurface"); //printf("\t width=%d height=%d stride=%d format=%d \n", buffer.width, buffer.height, buffer.stride, buffer.format); - /*for (unsigned int y = 0; y < buffer.height; y++) - { - unsigned int * line = (unsigned int *)bits + y * buffer.stride; - for (unsigned int x = 0; x < buffer.width; x++) - line[x] = 0xff00ff00; - }*/ gl->width = this->buffer->width; gl->height = this->buffer->height; gl->stride = this->buffer->stride; @@ -1926,15 +1920,7 @@ static struct S sp surface; ~S() { - //surface->dispose(); - surface.~sp(); - puts("surface.~sp()"); - //surfaceControl->dispose(); - surfaceControl.~sp(); - puts("surfaceControl.~sp()"); client->dispose(); - client.~sp(); - puts("client.~sp()"); } } * s = NULL; static ANativeWindow * window; @@ -2014,15 +2000,10 @@ extern "C" void * PresentDrawingSurface() extern "C" void DisposeDrawingSurface() { - puts("DisposeDrawingSurface"); eglDestroySurface(display, drawSurface); - puts("eglDestroySurface"); eglDestroyContext(display, eglCtx); - puts("eglDestroyContext"); delete s; - puts("delete s"); s = NULL; - puts("DisposeDrawingSurface"); } diff --git a/test/main.cpp b/test/main.cpp index d51c6d9..5bcb1ca 100644 --- a/test/main.cpp +++ b/test/main.cpp @@ -78,7 +78,7 @@ gl_shader_program * init_shader() ggl->ShaderAttach(ggl, program, vertShader); ggl->ShaderAttach(ggl, program, fragShader); const char * infoLog = NULL; - GLboolean linkStatus = ggl->ShaderProgramLink(ggl, program, &infoLog); + GLboolean linkStatus = ggl->ShaderProgramLink(program, &infoLog); printf("finished linking, LinkStatus=%d \n %s \n", linkStatus, infoLog); @@ -108,7 +108,7 @@ void test_scan() frameSurface.format = GGL_PIXEL_FORMAT_RGBA_8888; frameSurface.width = width; frameSurface.height = height; - + GGLSurface depthSurface = {0}; depthSurface.width = width; depthSurface.height = height; @@ -145,8 +145,8 @@ void test_scan() #endif texture.type = GL_TEXTURE_2D; texture.levelCount = 1; - texture.wrapS = texture.wrapT = 0; // repeat = 0 fastest, clamp = 1, mirrored = 2 - texture.minFilter = texture.magFilter = 0; // nearest = 0, linear = 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, @@ -171,7 +171,7 @@ void test_scan() ggl->SetBuffer(ggl, GL_COLOR_BUFFER_BIT, &frameSurface); - + ggl->EnableDisable(ggl, GL_DEPTH_TEST, true); ggl->DepthFunc(ggl, GL_LESS); @@ -195,7 +195,7 @@ void test_scan() 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, 1, 2, 1, 1}; + 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 }; @@ -264,8 +264,8 @@ void test_scan() 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"); @@ -278,7 +278,7 @@ void test_scan() #endif for ( #ifdef __arm__ - unsigned i = 0; i <= 360; i++ + unsigned i = 0; i <= 90; i++ #else unsigned i = 0; i <= 10; i+= 1 #endif @@ -326,7 +326,7 @@ void test_scan() //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]); + 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 @@ -429,7 +429,7 @@ void test_scan() ggl->SetBuffer(ggl, GL_COLOR_BUFFER_BIT, NULL); #if defined __arm__ && DRAW_TO_SCREEN - //DisposeDrawingSurface(); + DisposeDrawingSurface(); #else free(frameSurface.data); #endif @@ -451,10 +451,150 @@ void test_scan() extern "C" int cmain(int,char**); +#include "llvm/LLVMContext.h" + +void GLContextDctr(); + +void contextless_test() +{ + static const char vsGLSL [] = + "uniform vec4 uVec4; \n" + "uniform sampler2D sampler2d; \n" + "attribute vec4 aPosition; \n" + "attribute vec4 aTexCoord; \n" + "varying vec4 vTexCoord; \n" + "varying vec4 vTexColor; \n" + "void main() { \n" + " gl_Position = aPosition; \n" + " vTexCoord = aTexCoord; \n" + " vTexColor = texture2D(sampler2d, aTexCoord.zw); \n" + " gl_PointSize = 432.0; \n" + "}"; + gl_shader * vs = GGLShaderCreate(GL_VERTEX_SHADER); + const char * infoLog = NULL; + if (!GGLShaderCompile(vs, vsGLSL, &infoLog)) { + printf("GGLShaderCompile vs failed:\n%s\n", infoLog); + assert(0); + } + static const char fsGLSL [] = + "uniform vec4 uVec4; \n" + "uniform sampler2D sampler2d; \n" + "varying vec4 vTexCoord; \n" + "varying vec4 vTexColor; \n" + "void main() { \n" + " gl_FragColor = texture2D(sampler2d, vTexCoord.zw); \n" + "}"; + gl_shader * fs = GGLShaderCreate(GL_FRAGMENT_SHADER); + if (!GGLShaderCompile(fs, fsGLSL, &infoLog)) { + printf("GGLShaderCompile fs failed:\n%s\n", infoLog); + assert(0); + } + gl_shader_program * prog = GGLShaderProgramCreate(); + unsigned glError = GL_NO_ERROR; + glError = GGLShaderAttach(prog, vs); + assert(GL_NO_ERROR == glError); + glError = GGLShaderAttach(prog, fs); + assert(GL_NO_ERROR == glError); + GGLShaderAttributeBind(prog, 4, "aPosition"); + GGLShaderAttributeBind(prog, 5, "aTexCoord"); + if (!GGLShaderProgramLink(prog, &infoLog)) { + printf("GGLShaderProgramLink failed:\n%s\n", infoLog); + assert(0); + } + llvm::LLVMContext * llvmCtx = new llvm::LLVMContext(); + GGLState gglState = {0}; + unsigned texels0 [] = {0xff10ffff, 0x22222222, 0x66666666, 0xffffffff}; + GGLTexture_t texture0 = {GL_TEXTURE_2D, GGL_PIXEL_FORMAT_RGBA_8888, + 2, 2, 1, // width, height, levelCount + texels0, GGLTexture::GGL_CLAMP_TO_EDGE, GGLTexture::GGL_CLAMP_TO_EDGE, + GGLTexture::GGL_NEAREST, GGLTexture::GGL_NEAREST + }; + gglState.textureState.textures[0] = texture0; + gglState.textureState.textureData[0] = gglState.textureState.textures[0].levels; + gglState.textureState.textureDimensions[0 * 2 + 0] = gglState.textureState.textures[0].width; + gglState.textureState.textureDimensions[0 * 2 + 1] = gglState.textureState.textures[0].height; + GGLShaderUse(llvmCtx, &gglState, prog); + + VertexInput input = {0, 0, 0, 0, Vector4(0,0,0,1), Vector4(0,0,0,0)}; + VertexOutput output = {0}; + GGLProcessVertex(prog, &input, &output, NULL); + int vTexColor = -1; + GGLShaderVaryingLocation(prog, "vTexColor", &vTexColor); + if (vTexColor >= 0) { + if (((Vector4 *)&output)[vTexColor] != Vector4(1,1,16/255.0f,1)) { + puts("((Vector4 *)&output)[vTexColor] != Vector4(1,1,0,1)"); + assert(0); + } + } else { + puts("vTexColor < 0"); + assert(0); + } + + static const char fsGLSL1 [] = + "uniform vec4 uVec4; \n" + "uniform sampler2D sampler2d; \n" + "varying vec4 vTexCoord; \n" + "varying vec4 vTexColor; \n" + "void main() { \n" + " gl_FragColor = vTexColor; \n" + "}"; + gl_shader * fs1 = GGLShaderCreate(GL_FRAGMENT_SHADER); + if (!GGLShaderCompile(fs1, fsGLSL1, &infoLog)) { + printf("GGLShaderCompile fs failed:\n%s\n", infoLog); + assert(0); + } + gl_shader_program * prog1 = GGLShaderProgramCreate(); + glError = GGLShaderAttach(prog1, vs); + assert(GL_NO_ERROR == glError); + glError = GGLShaderAttach(prog1, fs1); + assert(GL_NO_ERROR == glError); + GGLShaderAttributeBind(prog1, 1, "aPosition"); + GGLShaderAttributeBind(prog1, 2, "aTexCoord"); + if (!GGLShaderProgramLink(prog1, &infoLog)) { + printf("GGLShaderProgramLink failed:\n%s\n", infoLog); + assert(0); + } + + GGLShaderUse(llvmCtx, &gglState, prog1); + VertexInput input1 = {0, Vector4(1,1,0,1), Vector4(1,1,0,0)}; + VertexOutput output1 = {0}; + GGLProcessVertex(prog1, &input1, &output1, NULL); + int vTexCoord = -1; + assert(2 == GGLShaderAttributeLocation(prog1, "aTexCoord")); + GGLShaderVaryingLocation(prog1, "vTexCoord", &vTexCoord); + if (vTexCoord >= 0) { + if (((Vector4 *)&output1)[vTexCoord] != input1.attributes[2]) { + puts("((Vector4 *)&output1)[vTexCoord] != input1.attributes[1]"); + assert(0); + } + } else { + puts("vTexCoord < 0"); + assert(0); + } + + puts("***\n finished contextless_test \n***"); + + GGLShaderProgramDelete(prog); + GGLShaderProgramDelete(prog1); + + 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; } diff --git a/test/mesa.project b/test/mesa.project index f88f153..d0ecf6b 100644 --- a/test/mesa.project +++ b/test/mesa.project @@ -15,12 +15,17 @@ + + + + - + + @@ -87,7 +92,4 @@ - - - -- cgit v1.2.3