struct glsl_sampler sampler_cubemap;
struct glsl_sampler sampler_1d_array;
struct glsl_sampler sampler_2d_array;
+ struct glsl_sampler sampler_cubemap_array;
};
/**
GLuint VAO;
GLuint VBO;
GLuint DepthFP;
- GLuint ShaderProg;
- GLuint RectShaderProg;
+ struct sampler_table samplers;
struct temp_texture depthTex;
};
GLuint VBO;
GLuint FBO;
GLuint Sampler;
- GLuint ShaderProg;
struct sampler_table samplers;
};
GLuint VAO;
GLuint VBO, FBO, RBO, Sampler;
GLint Width, Height;
+
+ struct sampler_table samplers;
};
/**
return 0;
}
- _mesa_GetProgramInfoLog(shader, size, NULL, info);
+ _mesa_GetShaderInfoLog(shader, size, NULL, info);
_mesa_problem(ctx,
"meta program compile failed:\n%s\n"
"source:\n%s\n",
*
* \returns a handle to a shader program on success or zero on failure.
*/
-static GLuint
-setup_shader_for_sampler(struct gl_context *ctx, struct glsl_sampler *sampler)
+static void
+setup_blit_shader(struct gl_context *ctx,
+ GLenum target,
+ struct sampler_table *table)
{
const char *vs_source;
char *fs_source;
GLuint vs, fs;
void *const mem_ctx = ralloc_context(NULL);
+ struct glsl_sampler *sampler =
+ setup_texture_sampler(target, table);
+
+ assert(sampler != NULL);
- if (sampler->shader_prog != 0)
- return sampler->shader_prog;
+ if (sampler->shader_prog != 0) {
+ _mesa_UseProgram(sampler->shader_prog);
+ return;
+ }
- if (ctx->API == API_OPENGLES2 || ctx->Const.GLSLVersion < 130) {
+ /* The version check is a little tricky. API is set to API_OPENGLES2 even
+ * for OpenGL ES 3.0 contexts, and GLSLVersion may be set to 140, for
+ * example, in an OpenGL ES 2.0 context.
+ */
+ if ((ctx->API == API_OPENGLES2 && ctx->Version < 30)
+ || ctx->Const.GLSLVersion < 130) {
vs_source =
"attribute vec2 position;\n"
"attribute vec3 textureCoords;\n"
- "varying vec3 texCoords;\n"
+ "varying vec4 texCoords;\n"
"void main()\n"
"{\n"
" texCoords = textureCoords;\n"
fs_source = ralloc_asprintf(mem_ctx,
"#extension GL_EXT_texture_array : enable\n"
+ "#extension GL_ARB_texture_cube_map_array: enable\n"
"#ifdef GL_ES\n"
"precision highp float;\n"
"#endif\n"
"uniform %s texSampler;\n"
- "varying vec3 texCoords;\n"
+ "varying vec4 texCoords;\n"
"void main()\n"
"{\n"
" gl_FragColor = %s(texSampler, %s);\n"
+ " gl_FragDepth = gl_FragColor.x;\n"
"}\n",
sampler->type,
sampler->func, sampler->texcoords);
vs_source = ralloc_asprintf(mem_ctx,
"#version %s\n"
"in vec2 position;\n"
- "in vec3 textureCoords;\n"
- "out vec3 texCoords;\n"
+ "in vec4 textureCoords;\n"
+ "out vec4 texCoords;\n"
"void main()\n"
"{\n"
" texCoords = textureCoords;\n"
_mesa_is_desktop_gl(ctx) ? "130" : "300 es");
fs_source = ralloc_asprintf(mem_ctx,
"#version %s\n"
+ "#extension GL_ARB_texture_cube_map_array: enable\n"
"#ifdef GL_ES\n"
"precision highp float;\n"
"#endif\n"
"uniform %s texSampler;\n"
- "in vec3 texCoords;\n"
+ "in vec4 texCoords;\n"
"out vec4 out_color;\n"
"\n"
"void main()\n"
"{\n"
" out_color = texture(texSampler, %s);\n"
+ " gl_FragDepth = out_color.x;\n"
"}\n",
_mesa_is_desktop_gl(ctx) ? "130" : "300 es",
sampler->type,
link_program_with_debug(ctx, sampler->shader_prog);
ralloc_free(mem_ctx);
- return sampler->shader_prog;
+ _mesa_UseProgram(sampler->shader_prog);
}
/**
struct blit_state *blit,
GLenum target)
{
- const char *vs_source;
- char *fs_source;
- GLuint vs, fs;
- void *mem_ctx;
- GLuint ShaderProg;
- GLboolean texture_2d = (target == GL_TEXTURE_2D);
-
/* target = GL_TEXTURE_RECTANGLE is not supported in GLES 3.0 */
- assert(_mesa_is_desktop_gl(ctx) || texture_2d);
+ assert(_mesa_is_desktop_gl(ctx) || target == GL_TEXTURE_2D);
setup_vertex_objects(&blit->VAO, &blit->VBO, true, 2, 2, 0);
- /* Generate a relevant fragment shader program for the texture target */
- if ((target == GL_TEXTURE_2D && blit->ShaderProg != 0) ||
- (target == GL_TEXTURE_RECTANGLE && blit->RectShaderProg != 0)) {
- return;
- }
-
- mem_ctx = ralloc_context(NULL);
-
- if (ctx->Const.GLSLVersion < 130) {
- vs_source =
- "attribute vec2 position;\n"
- "attribute vec2 textureCoords;\n"
- "varying vec2 texCoords;\n"
- "void main()\n"
- "{\n"
- " texCoords = textureCoords;\n"
- " gl_Position = vec4(position, 0.0, 1.0);\n"
- "}\n";
-
- fs_source = ralloc_asprintf(mem_ctx,
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "uniform %s texSampler;\n"
- "varying vec2 texCoords;\n"
- "void main()\n"
- "{\n"
- " gl_FragColor = %s(texSampler, texCoords);\n"
- " gl_FragDepth = gl_FragColor.r;\n"
- "}\n",
- texture_2d ? "sampler2D" : "sampler2DRect",
- texture_2d ? "texture2D" : "texture2DRect");
- }
- else {
- vs_source = ralloc_asprintf(mem_ctx,
- "#version %s\n"
- "in vec2 position;\n"
- "in vec2 textureCoords;\n"
- "out vec2 texCoords;\n"
- "void main()\n"
- "{\n"
- " texCoords = textureCoords;\n"
- " gl_Position = vec4(position, 0.0, 1.0);\n"
- "}\n",
- _mesa_is_desktop_gl(ctx) ? "130" : "300 es");
- fs_source = ralloc_asprintf(mem_ctx,
- "#version %s\n"
- "#ifdef GL_ES\n"
- "precision highp float;\n"
- "#endif\n"
- "uniform %s texSampler;\n"
- "in vec2 texCoords;\n"
- "out vec4 out_color;\n"
- "\n"
- "void main()\n"
- "{\n"
- " out_color = %s(texSampler, texCoords);\n"
- " gl_FragDepth = out_color.r;\n"
- "}\n",
- _mesa_is_desktop_gl(ctx) ? "130" : "300 es",
- texture_2d ? "sampler2D" : "sampler2DRect",
- texture_2d ? "texture" : "texture2DRect");
- }
-
- vs = compile_shader_with_debug(ctx, GL_VERTEX_SHADER, vs_source);
- fs = compile_shader_with_debug(ctx, GL_FRAGMENT_SHADER, fs_source);
-
- ShaderProg = _mesa_CreateProgramObjectARB();
- _mesa_AttachShader(ShaderProg, fs);
- _mesa_DeleteObjectARB(fs);
- _mesa_AttachShader(ShaderProg, vs);
- _mesa_DeleteObjectARB(vs);
- _mesa_BindAttribLocation(ShaderProg, 0, "position");
- _mesa_BindAttribLocation(ShaderProg, 1, "texcoords");
- link_program_with_debug(ctx, ShaderProg);
- ralloc_free(mem_ctx);
- if (texture_2d)
- blit->ShaderProg = ShaderProg;
- else
- blit->RectShaderProg = ShaderProg;
+ setup_blit_shader(ctx, target, &blit->samplers);
}
/**
*/
if (glsl_version) {
setup_glsl_blit_framebuffer(ctx, blit, target);
- if (target == GL_TEXTURE_2D)
- _mesa_UseProgram(blit->ShaderProg);
- else
- _mesa_UseProgram(blit->RectShaderProg);
}
else {
setup_ff_tnl_for_blit(&ctx->Meta->Blit.VAO,
*/
if (use_glsl_version) {
setup_glsl_blit_framebuffer(ctx, blit, tex->Target);
- if (tex->Target == GL_TEXTURE_2D)
- _mesa_UseProgram(blit->ShaderProg);
- else
- _mesa_UseProgram(blit->RectShaderProg);
}
else {
setup_ff_tnl_for_blit(&blit->VAO, &blit->VBO, 2);
blit->DepthFP = 0;
}
- _mesa_DeleteObjectARB(blit->ShaderProg);
- blit->ShaderProg = 0;
- _mesa_DeleteObjectARB(blit->RectShaderProg);
- blit->RectShaderProg = 0;
+ sampler_table_cleanup(&blit->samplers);
_mesa_DeleteTextures(1, &blit->depthTex.TexObj);
blit->depthTex.TexObj = 0;
assert(0);
}
+ coord[3] = (float) (slice / 6);
+
switch (faceTarget) {
case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
coord[0] = 1.0f;
*/
table->sampler_3d.type = "sampler3D";
table->sampler_3d.func = "texture3D";
- table->sampler_3d.texcoords = "texCoords";
+ table->sampler_3d.texcoords = "texCoords.xyz";
return &table->sampler_3d;
case GL_TEXTURE_CUBE_MAP:
table->sampler_cubemap.type = "samplerCube";
table->sampler_cubemap.func = "textureCube";
- table->sampler_cubemap.texcoords = "texCoords";
+ table->sampler_cubemap.texcoords = "texCoords.xyz";
return &table->sampler_cubemap;
case GL_TEXTURE_1D_ARRAY:
table->sampler_1d_array.type = "sampler1DArray";
case GL_TEXTURE_2D_ARRAY:
table->sampler_2d_array.type = "sampler2DArray";
table->sampler_2d_array.func = "texture2DArray";
- table->sampler_2d_array.texcoords = "texCoords";
+ table->sampler_2d_array.texcoords = "texCoords.xyz";
return &table->sampler_2d_array;
+ case GL_TEXTURE_CUBE_MAP_ARRAY:
+ table->sampler_cubemap_array.type = "samplerCubeArray";
+ table->sampler_cubemap_array.func = "textureCubeArray";
+ table->sampler_cubemap_array.texcoords = "texCoords.xyzw";
+ return &table->sampler_cubemap_array;
default:
_mesa_problem(NULL, "Unexpected texture target 0x%x in"
" setup_texture_sampler()\n", target);
_mesa_DeleteObjectARB(table->sampler_cubemap.shader_prog);
_mesa_DeleteObjectARB(table->sampler_1d_array.shader_prog);
_mesa_DeleteObjectARB(table->sampler_2d_array.shader_prog);
+ _mesa_DeleteObjectARB(table->sampler_cubemap_array.shader_prog);
table->sampler_1d.shader_prog = 0;
table->sampler_2d.shader_prog = 0;
table->sampler_cubemap.shader_prog = 0;
table->sampler_1d_array.shader_prog = 0;
table->sampler_2d_array.shader_prog = 0;
+ table->sampler_cubemap_array.shader_prog = 0;
}
static void
struct gen_mipmap_state *mipmap,
GLenum target)
{
- struct glsl_sampler *sampler;
-
setup_vertex_objects(&mipmap->VAO, &mipmap->VBO, true, 2, 3, 0);
- /* Generate a fragment shader program appropriate for the texture target */
- sampler = setup_texture_sampler(target, &mipmap->samplers);
- assert(sampler != NULL);
-
- mipmap->ShaderProg = setup_shader_for_sampler(ctx, sampler);
+ setup_blit_shader(ctx, target, &mipmap->samplers);
}
*/
if (use_glsl_version) {
setup_glsl_generate_mipmap(ctx, mipmap, target);
- _mesa_UseProgram(mipmap->ShaderProg);
}
else {
setup_ff_tnl_for_blit(&mipmap->VAO, &mipmap->VBO, 3);
GLuint fboDrawSave, fboReadSave;
GLuint rbSave;
GLuint samplerSave;
+ const bool use_glsl_version = ctx->Extensions.ARB_vertex_shader &&
+ ctx->Extensions.ARB_fragment_shader &&
+ (ctx->API != API_OPENGLES);
if (slice > 0) {
assert(target == GL_TEXTURE_3D ||
- target == GL_TEXTURE_2D_ARRAY);
+ target == GL_TEXTURE_2D_ARRAY ||
+ target == GL_TEXTURE_CUBE_MAP_ARRAY);
}
switch (target) {
assert(!"No compressed 3D textures.");
return;
- case GL_TEXTURE_2D_ARRAY:
case GL_TEXTURE_CUBE_MAP_ARRAY:
- /* These targets are just broken currently. */
- return;
+ faceTarget = GL_TEXTURE_CUBE_MAP_POSITIVE_X + (slice % 6);
+ break;
case GL_TEXTURE_CUBE_MAP:
faceTarget = GL_TEXTURE_CUBE_MAP_POSITIVE_X + texImage->Face;
decompress->Height = height;
}
- setup_ff_tnl_for_blit(&decompress->VAO, &decompress->VBO, 3);
+ if (use_glsl_version) {
+ setup_vertex_objects(&decompress->VAO, &decompress->VBO, true,
+ 2, 4, 0);
+
+ setup_blit_shader(ctx, target, &decompress->samplers);
+ } else {
+ setup_ff_tnl_for_blit(&decompress->VAO, &decompress->VBO, 3);
+ }
if (!decompress->Sampler) {
_mesa_GenSamplers(1, &decompress->Sampler);
/* setup texture state */
_mesa_BindTexture(target, texObj->Name);
- _mesa_set_enable(ctx, target, GL_TRUE);
+
+ if (!use_glsl_version)
+ _mesa_set_enable(ctx, target, GL_TRUE);
{
/* save texture object state */
}
/* disable texture unit */
- _mesa_set_enable(ctx, target, GL_FALSE);
+ if (!use_glsl_version)
+ _mesa_set_enable(ctx, target, GL_FALSE);
_mesa_BindSampler(ctx->Texture.CurrentUnit, samplerSave);
* unsigned, normalized values. We could handle signed and unnormalized
* with floating point renderbuffers...
*/
- if (texImage->TexObject->Target != GL_TEXTURE_CUBE_MAP_ARRAY
- && _mesa_is_format_compressed(texImage->TexFormat) &&
+ if (_mesa_is_format_compressed(texImage->TexFormat) &&
_mesa_get_format_datatype(texImage->TexFormat)
== GL_UNSIGNED_NORMALIZED) {
struct gl_texture_object *texObj = texImage->TexObject;
_mesa_unlock_texture(ctx, texObj);
for (slice = 0; slice < texImage->Depth; slice++) {
void *dst;
- if (texImage->TexObject->Target == GL_TEXTURE_2D_ARRAY) {
+ if (texImage->TexObject->Target == GL_TEXTURE_2D_ARRAY
+ || texImage->TexObject->Target == GL_TEXTURE_CUBE_MAP_ARRAY) {
/* Setup pixel packing. SkipPixels and SkipRows will be applied
* in the decompress_texture_image() function's call to
* glReadPixels but we need to compute the dest slice's address
projects / mesa.git / blobdiff