mirror of
https://github.com/brl/mutter.git
synced 2024-09-20 06:25:51 -04:00
6607306a2d
Under GLES2 we were defining the cogl_tex_coord_in varying as an array with a size determined by the number of texture coordinate arrays enabled whenever the program is used. This meant that we may have to regenerate the shader with a different size if the shader is used with more texture coord arrays later. However in OpenGL the equivalent builtin varying gl_TexCoord is simply defined as: varying vec4 gl_TexCoord[]; /* <-- no size */ GLSL is documented that if you declare an array with no size then you can only access it with a constant index and the size of the array will be determined by the highest index used. If you want to access it with a non-constant expression you need to redeclare the array yourself with a size. We can replicate the same behaviour in our Cogl shaders by instead declaring the cogl_tex_coord_in with no size. That way we don't have to pass around the number of tex coord attributes enabled when we flush a material. It also means that CoglShader can go back to directly uploading the source string to GL when cogl_shader_source is called so that we don't have to keep a copy of it around. If the user wants to access cogl_tex_coord_in with a non-constant index then they can simply redeclare the array themself. Hopefully developers will expect to have to do this if they are accustomed to the gl_TexCoord array.
398 lines
9.3 KiB
C
398 lines
9.3 KiB
C
/*
|
|
* Cogl
|
|
*
|
|
* An object oriented GL/GLES Abstraction/Utility Layer
|
|
*
|
|
* Copyright (C) 2007,2008,2009,2010 Intel Corporation.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
*
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include "cogl.h"
|
|
#include "cogl-shader-private.h"
|
|
#include "cogl-shader-boilerplate.h"
|
|
#include "cogl-internal.h"
|
|
#include "cogl-context.h"
|
|
#include "cogl-handle.h"
|
|
|
|
#include <glib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#ifdef HAVE_COGL_GL
|
|
#define glCreateShader ctx->drv.pf_glCreateShader
|
|
#define glGetShaderiv ctx->drv.pf_glGetShaderiv
|
|
#define glGetShaderInfoLog ctx->drv.pf_glGetShaderInfoLog
|
|
#define glCompileShader ctx->drv.pf_glCompileShader
|
|
#define glShaderSource ctx->drv.pf_glShaderSource
|
|
#define glDeleteShader ctx->drv.pf_glDeleteShader
|
|
#define glProgramString ctx->drv.pf_glProgramString
|
|
#define glBindProgram ctx->drv.pf_glBindProgram
|
|
#define glDeletePrograms ctx->drv.pf_glDeletePrograms
|
|
#define glGenPrograms ctx->drv.pf_glGenPrograms
|
|
#define GET_CONTEXT _COGL_GET_CONTEXT
|
|
#else
|
|
#define GET_CONTEXT(CTXVAR,RETVAL) G_STMT_START { } G_STMT_END
|
|
#endif
|
|
|
|
#ifndef HAVE_COGL_GLES
|
|
|
|
static void _cogl_shader_free (CoglShader *shader);
|
|
|
|
COGL_HANDLE_DEFINE (Shader, shader);
|
|
COGL_OBJECT_DEFINE_DEPRECATED_REF_COUNTING (shader);
|
|
|
|
static void
|
|
_cogl_shader_free (CoglShader *shader)
|
|
{
|
|
/* Frees shader resources but its handle is not
|
|
released! Do that separately before this! */
|
|
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
|
|
|
|
#ifdef HAVE_COGL_GL
|
|
if (shader->language == COGL_SHADER_LANGUAGE_ARBFP)
|
|
{
|
|
if (shader->gl_handle)
|
|
GE (glDeletePrograms (1, &shader->gl_handle));
|
|
}
|
|
else
|
|
#endif
|
|
if (shader->gl_handle)
|
|
GE (glDeleteShader (shader->gl_handle));
|
|
|
|
g_slice_free (CoglShader, shader);
|
|
}
|
|
|
|
CoglHandle
|
|
cogl_create_shader (CoglShaderType type)
|
|
{
|
|
CoglShader *shader;
|
|
|
|
GET_CONTEXT (ctx, COGL_INVALID_HANDLE);
|
|
|
|
switch (type)
|
|
{
|
|
case COGL_SHADER_TYPE_VERTEX:
|
|
case COGL_SHADER_TYPE_FRAGMENT:
|
|
break;
|
|
default:
|
|
g_warning ("Unexpected shader type (0x%08lX) given to "
|
|
"cogl_create_shader", (unsigned long) type);
|
|
return COGL_INVALID_HANDLE;
|
|
}
|
|
|
|
shader = g_slice_new (CoglShader);
|
|
shader->language = COGL_SHADER_LANGUAGE_GLSL;
|
|
shader->gl_handle = 0;
|
|
shader->type = type;
|
|
|
|
return _cogl_shader_handle_new (shader);
|
|
}
|
|
|
|
void
|
|
_cogl_shader_set_source_with_boilerplate (GLuint shader_gl_handle,
|
|
GLenum shader_gl_type,
|
|
GLsizei count_in,
|
|
const char **strings_in,
|
|
const GLint *lengths_in)
|
|
{
|
|
static const char vertex_boilerplate[] = _COGL_VERTEX_SHADER_BOILERPLATE;
|
|
static const char fragment_boilerplate[] = _COGL_FRAGMENT_SHADER_BOILERPLATE;
|
|
|
|
const char **strings = g_alloca (sizeof (char *) * (count_in + 2));
|
|
GLint *lengths = g_alloca (sizeof (GLint) * (count_in + 2));
|
|
int count = 0;
|
|
|
|
GET_CONTEXT (ctx, NO_RETVAL);
|
|
|
|
if (shader_gl_type == GL_VERTEX_SHADER)
|
|
{
|
|
strings[count] = vertex_boilerplate;
|
|
lengths[count++] = sizeof (vertex_boilerplate) - 1;
|
|
}
|
|
else if (shader_gl_type == GL_FRAGMENT_SHADER)
|
|
{
|
|
strings[count] = fragment_boilerplate;
|
|
lengths[count++] = sizeof (fragment_boilerplate) - 1;
|
|
}
|
|
|
|
memcpy (strings + count, strings_in, sizeof (char *) * count_in);
|
|
if (lengths_in)
|
|
memcpy (lengths + count, lengths_in, sizeof (GLint) * count_in);
|
|
else
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < count_in; i++)
|
|
lengths[count + i] = -1; /* null terminated */
|
|
}
|
|
count += count_in;
|
|
|
|
GE( glShaderSource (shader_gl_handle, count,
|
|
(const char **) strings, lengths) );
|
|
}
|
|
|
|
void
|
|
cogl_shader_source (CoglHandle handle,
|
|
const char *source)
|
|
{
|
|
CoglShader *shader;
|
|
CoglShaderLanguage language;
|
|
|
|
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
|
|
|
|
if (!cogl_is_shader (handle))
|
|
return;
|
|
|
|
shader = _cogl_shader_pointer_from_handle (handle);
|
|
|
|
#ifdef HAVE_COGL_GL
|
|
if (strncmp (source, "!!ARBfp1.0", 10) == 0)
|
|
language = COGL_SHADER_LANGUAGE_ARBFP;
|
|
else
|
|
#endif
|
|
language = COGL_SHADER_LANGUAGE_GLSL;
|
|
|
|
/* Delete the old object if the language is changing... */
|
|
if (G_UNLIKELY (language != shader->language))
|
|
{
|
|
#ifdef HAVE_COGL_GL
|
|
if (shader->language == COGL_SHADER_LANGUAGE_ARBFP)
|
|
{
|
|
if (shader->gl_handle)
|
|
GE (glDeletePrograms (1, &shader->gl_handle));
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
if (shader->gl_handle)
|
|
GE (glDeleteShader (shader->gl_handle));
|
|
}
|
|
}
|
|
|
|
#ifdef HAVE_COGL_GL
|
|
if (language == COGL_SHADER_LANGUAGE_ARBFP)
|
|
{
|
|
#ifdef COGL_GL_DEBUG
|
|
GLenum gl_error;
|
|
#endif
|
|
|
|
if (shader->gl_handle == 0)
|
|
GE (glGenPrograms (1, &shader->gl_handle));
|
|
|
|
GE (glBindProgram (GL_FRAGMENT_PROGRAM_ARB, shader->gl_handle));
|
|
|
|
#ifdef COGL_GL_DEBUG
|
|
while ((gl_error = glGetError ()) != GL_NO_ERROR)
|
|
;
|
|
#endif
|
|
glProgramString (GL_FRAGMENT_PROGRAM_ARB,
|
|
GL_PROGRAM_FORMAT_ASCII_ARB,
|
|
strlen (source),
|
|
source);
|
|
#ifdef COGL_GL_DEBUG
|
|
gl_error = glGetError ();
|
|
if (gl_error != GL_NO_ERROR)
|
|
{
|
|
g_warning ("%s: GL error (%d): Failed to compile ARBfp:\n%s\n%s",
|
|
G_STRLOC,
|
|
gl_error,
|
|
source,
|
|
glGetString (GL_PROGRAM_ERROR_STRING_ARB));
|
|
}
|
|
#endif
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
GLenum gl_type;
|
|
|
|
switch (shader->type)
|
|
{
|
|
case COGL_SHADER_TYPE_VERTEX:
|
|
gl_type = GL_VERTEX_SHADER;
|
|
break;
|
|
case COGL_SHADER_TYPE_FRAGMENT:
|
|
gl_type = GL_FRAGMENT_SHADER;
|
|
break;
|
|
default:
|
|
g_assert_not_reached ();
|
|
break;
|
|
}
|
|
|
|
if (!shader->gl_handle)
|
|
shader->gl_handle = glCreateShader (gl_type);
|
|
|
|
_cogl_shader_set_source_with_boilerplate (shader->gl_handle,
|
|
gl_type,
|
|
1, &source, NULL);
|
|
}
|
|
|
|
shader->language = language;
|
|
}
|
|
|
|
void
|
|
cogl_shader_compile (CoglHandle handle)
|
|
{
|
|
CoglShader *shader;
|
|
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
|
|
|
|
if (!cogl_is_shader (handle))
|
|
return;
|
|
|
|
shader = _cogl_shader_pointer_from_handle (handle);
|
|
|
|
if (shader->language == COGL_SHADER_LANGUAGE_GLSL)
|
|
GE (glCompileShader (shader->gl_handle));
|
|
}
|
|
|
|
char *
|
|
cogl_shader_get_info_log (CoglHandle handle)
|
|
{
|
|
CoglShader *shader;
|
|
|
|
GET_CONTEXT (ctx, NULL);
|
|
|
|
if (!cogl_is_shader (handle))
|
|
return NULL;
|
|
|
|
shader = _cogl_shader_pointer_from_handle (handle);
|
|
|
|
#ifdef HAVE_COGL_GL
|
|
if (shader->language == COGL_SHADER_LANGUAGE_ARBFP)
|
|
{
|
|
/* ARBfp exposes a program error string, but since cogl_program
|
|
* doesn't have any API to query an error log it is not currently
|
|
* exposed. */
|
|
return g_strdup ("");
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
char buffer[512];
|
|
int len = 0;
|
|
glGetShaderInfoLog (shader->gl_handle, 511, &len, buffer);
|
|
buffer[len] = '\0';
|
|
return g_strdup (buffer);
|
|
}
|
|
}
|
|
|
|
CoglShaderType
|
|
cogl_shader_get_type (CoglHandle handle)
|
|
{
|
|
CoglShader *shader;
|
|
|
|
GET_CONTEXT (ctx, COGL_SHADER_TYPE_VERTEX);
|
|
|
|
if (!cogl_is_shader (handle))
|
|
{
|
|
g_warning ("Non shader handle type passed to cogl_shader_get_type");
|
|
return COGL_SHADER_TYPE_VERTEX;
|
|
}
|
|
|
|
shader = _cogl_shader_pointer_from_handle (handle);
|
|
return shader->type;
|
|
}
|
|
|
|
gboolean
|
|
cogl_shader_is_compiled (CoglHandle handle)
|
|
{
|
|
GLint status;
|
|
CoglShader *shader;
|
|
|
|
GET_CONTEXT (ctx, FALSE);
|
|
|
|
if (!cogl_is_shader (handle))
|
|
return FALSE;
|
|
|
|
shader = _cogl_shader_pointer_from_handle (handle);
|
|
|
|
#ifdef HAVE_COGL_GL
|
|
if (shader->language == COGL_SHADER_LANGUAGE_ARBFP)
|
|
return TRUE;
|
|
else
|
|
#endif
|
|
{
|
|
GE (glGetShaderiv (shader->gl_handle, GL_COMPILE_STATUS, &status));
|
|
if (status == GL_TRUE)
|
|
return TRUE;
|
|
else
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
#else /* HAVE_COGL_GLES */
|
|
|
|
/* No support on regular OpenGL 1.1 */
|
|
|
|
CoglHandle
|
|
cogl_create_shader (CoglShaderType type)
|
|
{
|
|
return COGL_INVALID_HANDLE;
|
|
}
|
|
|
|
gboolean
|
|
cogl_is_shader (CoglHandle handle)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
CoglHandle
|
|
cogl_shader_ref (CoglHandle handle)
|
|
{
|
|
return COGL_INVALID_HANDLE;
|
|
}
|
|
|
|
void
|
|
cogl_shader_unref (CoglHandle handle)
|
|
{
|
|
}
|
|
|
|
void
|
|
cogl_shader_source (CoglHandle shader,
|
|
const char *source)
|
|
{
|
|
}
|
|
|
|
void
|
|
cogl_shader_compile (CoglHandle shader_handle)
|
|
{
|
|
}
|
|
|
|
char *
|
|
cogl_shader_get_info_log (CoglHandle handle)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
CoglShaderType
|
|
cogl_shader_get_type (CoglHandle handle)
|
|
{
|
|
return COGL_SHADER_TYPE_VERTEX;
|
|
}
|
|
|
|
gboolean
|
|
cogl_shader_is_compiled (CoglHandle handle)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
#endif /* HAVE_COGL_GLES */
|