Import GLSL brick demo (small change: no glew, which one day we should support though).
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@37921 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Philippe Houdoin
@@ -3,3 +3,5 @@ SubDir HAIKU_TOP src tests kits opengl ;
|
||||
SubInclude HAIKU_TOP src tests kits opengl direct_mode ;
|
||||
SubInclude HAIKU_TOP src tests kits opengl demos ;
|
||||
SubInclude HAIKU_TOP src tests kits opengl glut ;
|
||||
SubInclude HAIKU_TOP src tests kits opengl glsl ;
|
||||
|
||||
|
||||
@@ -0,0 +1,36 @@
|
||||
//
|
||||
// Fragment shader for procedural bricks
|
||||
//
|
||||
// Authors: Dave Baldwin, Steve Koren, Randi Rost
|
||||
// based on a shader by Darwyn Peachey
|
||||
//
|
||||
// Copyright (c) 2002-2006 3Dlabs Inc. Ltd.
|
||||
//
|
||||
// See 3Dlabs-License.txt for license information
|
||||
//
|
||||
|
||||
uniform vec3 BrickColor, MortarColor;
|
||||
uniform vec2 BrickSize;
|
||||
uniform vec2 BrickPct;
|
||||
|
||||
varying vec2 MCposition;
|
||||
varying float LightIntensity;
|
||||
|
||||
void main()
|
||||
{
|
||||
vec3 color;
|
||||
vec2 position, useBrick;
|
||||
|
||||
position = MCposition / BrickSize;
|
||||
|
||||
if (fract(position.y * 0.5) > 0.5)
|
||||
position.x += 0.5;
|
||||
|
||||
position = fract(position);
|
||||
|
||||
useBrick = step(position, BrickPct);
|
||||
|
||||
color = mix(MortarColor, BrickColor, useBrick.x * useBrick.y);
|
||||
color *= LightIntensity;
|
||||
gl_FragColor = vec4(color, 1.0);
|
||||
}
|
||||
@@ -0,0 +1,41 @@
|
||||
//
|
||||
// Vertex shader for procedural bricks
|
||||
//
|
||||
// Authors: Dave Baldwin, Steve Koren, Randi Rost
|
||||
// based on a shader by Darwyn Peachey
|
||||
//
|
||||
// Copyright (c) 2002-2006 3Dlabs Inc. Ltd.
|
||||
//
|
||||
// See 3Dlabs-License.txt for license information
|
||||
//
|
||||
|
||||
uniform vec3 LightPosition;
|
||||
|
||||
const float SpecularContribution = 0.3;
|
||||
const float DiffuseContribution = 1.0 - SpecularContribution;
|
||||
|
||||
varying float LightIntensity;
|
||||
varying vec2 MCposition;
|
||||
|
||||
void main()
|
||||
{
|
||||
vec3 ecPosition = vec3(gl_ModelViewMatrix * gl_Vertex);
|
||||
vec3 tnorm = normalize(gl_NormalMatrix * gl_Normal);
|
||||
vec3 lightVec = normalize(LightPosition - ecPosition);
|
||||
vec3 reflectVec = reflect(-lightVec, tnorm);
|
||||
vec3 viewVec = normalize(-ecPosition);
|
||||
float diffuse = max(dot(lightVec, tnorm), 0.0);
|
||||
float spec = 0.0;
|
||||
|
||||
if (diffuse > 0.0)
|
||||
{
|
||||
spec = max(dot(reflectVec, viewVec), 0.0);
|
||||
spec = pow(spec, 16.0);
|
||||
}
|
||||
|
||||
LightIntensity = DiffuseContribution * diffuse +
|
||||
SpecularContribution * spec;
|
||||
|
||||
MCposition = gl_Vertex.xy;
|
||||
gl_Position = ftransform();
|
||||
}
|
||||
@@ -0,0 +1,19 @@
|
||||
SubDir HAIKU_TOP src tests kits opengl glsl ;
|
||||
|
||||
SetSubDirSupportedPlatformsBeOSCompatible ;
|
||||
|
||||
if $(TARGET_PLATFORM) != haiku {
|
||||
# Needed for <GL/glut.h>, not present in R5.
|
||||
# Unfortunately we also get the other headers there,
|
||||
# that we don't really want.
|
||||
UsePublicHeaders opengl ;
|
||||
}
|
||||
|
||||
StaticLibrary libshaderutil.a :
|
||||
shaderutil.c
|
||||
;
|
||||
|
||||
SimpleTest brick :
|
||||
brick.c
|
||||
: libshaderutil.a be GL
|
||||
;
|
||||
@@ -0,0 +1,201 @@
|
||||
/**
|
||||
* "Brick" shader demo. Uses the example shaders from chapter 6 of
|
||||
* the OpenGL Shading Language "orange" book.
|
||||
* 10 Jan 2007
|
||||
*/
|
||||
|
||||
#include <assert.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <math.h>
|
||||
// #include <GL/glew.h>
|
||||
#include <GL/glut.h>
|
||||
#include <GL/glext.h>
|
||||
#include "shaderutil.h"
|
||||
|
||||
|
||||
static char *FragProgFile = "CH06-brick.frag";
|
||||
static char *VertProgFile = "CH06-brick.vert";
|
||||
|
||||
/* program/shader objects */
|
||||
static GLuint fragShader;
|
||||
static GLuint vertShader;
|
||||
static GLuint program;
|
||||
|
||||
static struct uniform_info Uniforms[] = {
|
||||
/* vert */
|
||||
{ "LightPosition", 1, GL_FLOAT_VEC3, { 0.1, 0.1, 9.0, 0}, -1 },
|
||||
/* frag */
|
||||
{ "BrickColor", 1, GL_FLOAT_VEC3, { 0.8, 0.2, 0.2, 0 }, -1 },
|
||||
{ "MortarColor", 1, GL_FLOAT_VEC3, { 0.6, 0.6, 0.6, 0 }, -1 },
|
||||
{ "BrickSize", 1, GL_FLOAT_VEC2, { 1.0, 0.3, 0, 0 }, -1 },
|
||||
{ "BrickPct", 1, GL_FLOAT_VEC2, { 0.9, 0.8, 0, 0 }, -1 },
|
||||
END_OF_UNIFORMS
|
||||
};
|
||||
|
||||
static GLint win = 0;
|
||||
|
||||
|
||||
static GLfloat xRot = 0.0f, yRot = 0.0f, zRot = 0.0f;
|
||||
|
||||
|
||||
|
||||
|
||||
static void
|
||||
Redisplay(void)
|
||||
{
|
||||
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
||||
|
||||
glPushMatrix();
|
||||
glRotatef(xRot, 1.0f, 0.0f, 0.0f);
|
||||
glRotatef(yRot, 0.0f, 1.0f, 0.0f);
|
||||
glRotatef(zRot, 0.0f, 0.0f, 1.0f);
|
||||
|
||||
glBegin(GL_POLYGON);
|
||||
glTexCoord2f(0, 0); glVertex2f(-2, -2);
|
||||
glTexCoord2f(1, 0); glVertex2f( 2, -2);
|
||||
glTexCoord2f(1, 1); glVertex2f( 2, 2);
|
||||
glTexCoord2f(0, 1); glVertex2f(-2, 2);
|
||||
glEnd();
|
||||
|
||||
glPopMatrix();
|
||||
|
||||
glutSwapBuffers();
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
Reshape(int width, int height)
|
||||
{
|
||||
glViewport(0, 0, width, height);
|
||||
glMatrixMode(GL_PROJECTION);
|
||||
glLoadIdentity();
|
||||
glFrustum(-1.0, 1.0, -1.0, 1.0, 5.0, 25.0);
|
||||
glMatrixMode(GL_MODELVIEW);
|
||||
glLoadIdentity();
|
||||
glTranslatef(0.0f, 0.0f, -15.0f);
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
CleanUp(void)
|
||||
{
|
||||
glDeleteShader(fragShader);
|
||||
glDeleteShader(vertShader);
|
||||
glDeleteProgram(program);
|
||||
glutDestroyWindow(win);
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
Key(unsigned char key, int x, int y)
|
||||
{
|
||||
(void) x;
|
||||
(void) y;
|
||||
|
||||
switch(key) {
|
||||
case 'z':
|
||||
zRot -= 1.0;
|
||||
break;
|
||||
case 'Z':
|
||||
zRot += 1.0;
|
||||
break;
|
||||
case 27:
|
||||
CleanUp();
|
||||
exit(0);
|
||||
break;
|
||||
}
|
||||
glutPostRedisplay();
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
SpecialKey(int key, int x, int y)
|
||||
{
|
||||
const GLfloat step = 3.0f;
|
||||
|
||||
(void) x;
|
||||
(void) y;
|
||||
|
||||
switch(key) {
|
||||
case GLUT_KEY_UP:
|
||||
xRot -= step;
|
||||
break;
|
||||
case GLUT_KEY_DOWN:
|
||||
xRot += step;
|
||||
break;
|
||||
case GLUT_KEY_LEFT:
|
||||
yRot -= step;
|
||||
break;
|
||||
case GLUT_KEY_RIGHT:
|
||||
yRot += step;
|
||||
break;
|
||||
}
|
||||
glutPostRedisplay();
|
||||
}
|
||||
|
||||
|
||||
|
||||
static void
|
||||
Init(void)
|
||||
{
|
||||
if (!ShadersSupported())
|
||||
exit(1);
|
||||
|
||||
vertShader = CompileShaderFile(GL_VERTEX_SHADER, VertProgFile);
|
||||
fragShader = CompileShaderFile(GL_FRAGMENT_SHADER, FragProgFile);
|
||||
program = LinkShaders(vertShader, fragShader);
|
||||
|
||||
glUseProgram(program);
|
||||
|
||||
SetUniformValues(program, Uniforms);
|
||||
PrintUniforms(Uniforms);
|
||||
|
||||
assert(glGetError() == 0);
|
||||
|
||||
glClearColor(0.4f, 0.4f, 0.8f, 0.0f);
|
||||
|
||||
printf("GL_RENDERER = %s\n",(const char *) glGetString(GL_RENDERER));
|
||||
|
||||
assert(glIsProgram(program));
|
||||
assert(glIsShader(fragShader));
|
||||
assert(glIsShader(vertShader));
|
||||
|
||||
glColor3f(1, 0, 0);
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
ParseOptions(int argc, char *argv[])
|
||||
{
|
||||
int i;
|
||||
for (i = 1; i < argc; i++) {
|
||||
if (strcmp(argv[i], "-fs") == 0) {
|
||||
FragProgFile = argv[i+1];
|
||||
}
|
||||
else if (strcmp(argv[i], "-vs") == 0) {
|
||||
VertProgFile = argv[i+1];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
main(int argc, char *argv[])
|
||||
{
|
||||
glutInit(&argc, argv);
|
||||
glutInitWindowSize(400, 400);
|
||||
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
|
||||
win = glutCreateWindow(argv[0]);
|
||||
// glewInit();
|
||||
glutReshapeFunc(Reshape);
|
||||
glutKeyboardFunc(Key);
|
||||
glutSpecialFunc(SpecialKey);
|
||||
glutDisplayFunc(Redisplay);
|
||||
ParseOptions(argc, argv);
|
||||
Init();
|
||||
glutMainLoop();
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,323 @@
|
||||
/**
|
||||
* Utilities for OpenGL shading language
|
||||
*
|
||||
* Brian Paul
|
||||
* 9 April 2008
|
||||
*/
|
||||
|
||||
|
||||
#include <assert.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
// #include <GL/glew.h>
|
||||
#include <GL/glut.h>
|
||||
#include "shaderutil.h"
|
||||
|
||||
/** time to compile previous shader */
|
||||
static GLdouble CompileTime = 0.0;
|
||||
|
||||
/** time to linke previous program */
|
||||
static GLdouble LinkTime = 0.0;
|
||||
|
||||
|
||||
GLboolean
|
||||
ShadersSupported(void)
|
||||
{
|
||||
const char *version = (const char *) glGetString(GL_VERSION);
|
||||
|
||||
/* NVIDIA binary drivers will return "3.0.0", and they clearly support
|
||||
* shaders.
|
||||
*/
|
||||
if (version[0] >= '2' && version[1] == '.') {
|
||||
return GL_TRUE;
|
||||
}
|
||||
else if (glutExtensionSupported("GL_ARB_vertex_shader")
|
||||
&& glutExtensionSupported("GL_ARB_fragment_shader")
|
||||
&& glutExtensionSupported("GL_ARB_shader_objects")) {
|
||||
fprintf(stderr, "Warning: Trying ARB GLSL instead of OpenGL 2.x. This may not work.\n");
|
||||
return GL_TRUE;
|
||||
}
|
||||
fprintf(stderr, "Sorry, GLSL not supported with this OpenGL.\n");
|
||||
return GL_FALSE;
|
||||
}
|
||||
|
||||
|
||||
GLuint
|
||||
CompileShaderText(GLenum shaderType, const char *text)
|
||||
{
|
||||
GLuint shader;
|
||||
GLint stat;
|
||||
GLdouble t0, t1;
|
||||
|
||||
shader = glCreateShader(shaderType);
|
||||
glShaderSource(shader, 1, (const GLchar **) &text, NULL);
|
||||
|
||||
t0 = glutGet(GLUT_ELAPSED_TIME) * 0.001;
|
||||
glCompileShader(shader);
|
||||
t1 = glutGet(GLUT_ELAPSED_TIME) * 0.001;
|
||||
|
||||
CompileTime = t1 - t0;
|
||||
|
||||
glGetShaderiv(shader, GL_COMPILE_STATUS, &stat);
|
||||
if (!stat) {
|
||||
GLchar log[1000];
|
||||
GLsizei len;
|
||||
glGetShaderInfoLog(shader, 1000, &len, log);
|
||||
fprintf(stderr, "Error: problem compiling shader: %s\n", log);
|
||||
exit(1);
|
||||
}
|
||||
else {
|
||||
/*printf("Shader compiled OK\n");*/
|
||||
}
|
||||
return shader;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Read a shader from a file.
|
||||
*/
|
||||
GLuint
|
||||
CompileShaderFile(GLenum shaderType, const char *filename)
|
||||
{
|
||||
const int max = 100*1000;
|
||||
int n;
|
||||
char *buffer = (char*) malloc(max);
|
||||
GLuint shader;
|
||||
FILE *f;
|
||||
|
||||
f = fopen(filename, "r");
|
||||
if (!f) {
|
||||
fprintf(stderr, "Unable to open shader file %s\n", filename);
|
||||
free(buffer);
|
||||
return 0;
|
||||
}
|
||||
|
||||
n = fread(buffer, 1, max, f);
|
||||
/*printf("read %d bytes from shader file %s\n", n, filename);*/
|
||||
if (n > 0) {
|
||||
buffer[n] = 0;
|
||||
shader = CompileShaderText(shaderType, buffer);
|
||||
}
|
||||
else {
|
||||
fclose(f);
|
||||
free(buffer);
|
||||
return 0;
|
||||
}
|
||||
|
||||
fclose(f);
|
||||
free(buffer);
|
||||
|
||||
return shader;
|
||||
}
|
||||
|
||||
|
||||
GLuint
|
||||
LinkShaders(GLuint vertShader, GLuint fragShader)
|
||||
{
|
||||
GLuint program = glCreateProgram();
|
||||
GLdouble t0, t1;
|
||||
|
||||
assert(vertShader || fragShader);
|
||||
|
||||
if (fragShader)
|
||||
glAttachShader(program, fragShader);
|
||||
if (vertShader)
|
||||
glAttachShader(program, vertShader);
|
||||
|
||||
t0 = glutGet(GLUT_ELAPSED_TIME) * 0.001;
|
||||
glLinkProgram(program);
|
||||
t1 = glutGet(GLUT_ELAPSED_TIME) * 0.001;
|
||||
|
||||
LinkTime = t1 - t0;
|
||||
|
||||
/* check link */
|
||||
{
|
||||
GLint stat;
|
||||
glGetProgramiv(program, GL_LINK_STATUS, &stat);
|
||||
if (!stat) {
|
||||
GLchar log[1000];
|
||||
GLsizei len;
|
||||
glGetProgramInfoLog(program, 1000, &len, log);
|
||||
fprintf(stderr, "Shader link error:\n%s\n", log);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
return program;
|
||||
}
|
||||
|
||||
|
||||
GLboolean
|
||||
ValidateShaderProgram(GLuint program)
|
||||
{
|
||||
GLint stat;
|
||||
glValidateProgramARB(program);
|
||||
glGetProgramiv(program, GL_VALIDATE_STATUS, &stat);
|
||||
|
||||
if (!stat) {
|
||||
GLchar log[1000];
|
||||
GLsizei len;
|
||||
glGetProgramInfoLog(program, 1000, &len, log);
|
||||
fprintf(stderr, "Program validation error:\n%s\n", log);
|
||||
return 0;
|
||||
}
|
||||
|
||||
return (GLboolean) stat;
|
||||
}
|
||||
|
||||
|
||||
GLdouble
|
||||
GetShaderCompileTime(void)
|
||||
{
|
||||
return CompileTime;
|
||||
}
|
||||
|
||||
|
||||
GLdouble
|
||||
GetShaderLinkTime(void)
|
||||
{
|
||||
return LinkTime;
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
SetUniformValues(GLuint program, struct uniform_info uniforms[])
|
||||
{
|
||||
GLuint i;
|
||||
|
||||
for (i = 0; uniforms[i].name; i++) {
|
||||
uniforms[i].location
|
||||
= glGetUniformLocation(program, uniforms[i].name);
|
||||
|
||||
switch (uniforms[i].type) {
|
||||
case GL_INT:
|
||||
case GL_SAMPLER_1D:
|
||||
case GL_SAMPLER_2D:
|
||||
case GL_SAMPLER_3D:
|
||||
case GL_SAMPLER_CUBE:
|
||||
case GL_SAMPLER_2D_RECT_ARB:
|
||||
assert(uniforms[i].value[0] >= 0.0F);
|
||||
glUniform1i(uniforms[i].location,
|
||||
(GLint) uniforms[i].value[0]);
|
||||
break;
|
||||
case GL_FLOAT:
|
||||
glUniform1fv(uniforms[i].location, 1, uniforms[i].value);
|
||||
break;
|
||||
case GL_FLOAT_VEC2:
|
||||
glUniform2fv(uniforms[i].location, 1, uniforms[i].value);
|
||||
break;
|
||||
case GL_FLOAT_VEC3:
|
||||
glUniform3fv(uniforms[i].location, 1, uniforms[i].value);
|
||||
break;
|
||||
case GL_FLOAT_VEC4:
|
||||
glUniform4fv(uniforms[i].location, 1, uniforms[i].value);
|
||||
break;
|
||||
default:
|
||||
if (strncmp(uniforms[i].name, "gl_", 3) == 0) {
|
||||
/* built-in uniform: ignore */
|
||||
}
|
||||
else {
|
||||
fprintf(stderr,
|
||||
"Unexpected uniform data type in SetUniformValues\n");
|
||||
abort();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/** Get list of uniforms used in the program */
|
||||
GLuint
|
||||
GetUniforms(GLuint program, struct uniform_info uniforms[])
|
||||
{
|
||||
GLint n, max, i;
|
||||
|
||||
glGetProgramiv(program, GL_ACTIVE_UNIFORMS, &n);
|
||||
glGetProgramiv(program, GL_ACTIVE_UNIFORM_MAX_LENGTH, &max);
|
||||
|
||||
for (i = 0; i < n; i++) {
|
||||
GLint size, len;
|
||||
GLenum type;
|
||||
char name[100];
|
||||
|
||||
glGetActiveUniform(program, i, 100, &len, &size, &type, name);
|
||||
|
||||
uniforms[i].name = strdup(name);
|
||||
uniforms[i].size = size;
|
||||
uniforms[i].type = type;
|
||||
uniforms[i].location = glGetUniformLocation(program, name);
|
||||
}
|
||||
|
||||
uniforms[i].name = NULL; /* end of list */
|
||||
|
||||
return n;
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
PrintUniforms(const struct uniform_info uniforms[])
|
||||
{
|
||||
GLint i;
|
||||
|
||||
printf("Uniforms:\n");
|
||||
|
||||
for (i = 0; uniforms[i].name; i++) {
|
||||
printf(" %d: %s size=%d type=0x%x loc=%d value=%g, %g, %g, %g\n",
|
||||
i,
|
||||
uniforms[i].name,
|
||||
uniforms[i].size,
|
||||
uniforms[i].type,
|
||||
uniforms[i].location,
|
||||
uniforms[i].value[0],
|
||||
uniforms[i].value[1],
|
||||
uniforms[i].value[2],
|
||||
uniforms[i].value[3]);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/** Get list of attribs used in the program */
|
||||
GLuint
|
||||
GetAttribs(GLuint program, struct attrib_info attribs[])
|
||||
{
|
||||
GLint n, max, i;
|
||||
|
||||
glGetProgramiv(program, GL_ACTIVE_ATTRIBUTES, &n);
|
||||
glGetProgramiv(program, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &max);
|
||||
|
||||
for (i = 0; i < n; i++) {
|
||||
GLint size, len;
|
||||
GLenum type;
|
||||
char name[100];
|
||||
|
||||
glGetActiveAttrib(program, i, 100, &len, &size, &type, name);
|
||||
|
||||
attribs[i].name = strdup(name);
|
||||
attribs[i].size = size;
|
||||
attribs[i].type = type;
|
||||
attribs[i].location = glGetAttribLocation(program, name);
|
||||
}
|
||||
|
||||
attribs[i].name = NULL; /* end of list */
|
||||
|
||||
return n;
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
PrintAttribs(const struct attrib_info attribs[])
|
||||
{
|
||||
GLint i;
|
||||
|
||||
printf("Attribs:\n");
|
||||
|
||||
for (i = 0; attribs[i].name; i++) {
|
||||
printf(" %d: %s size=%d type=0x%x loc=%d\n",
|
||||
i,
|
||||
attribs[i].name,
|
||||
attribs[i].size,
|
||||
attribs[i].type,
|
||||
attribs[i].location);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,63 @@
|
||||
#ifndef SHADER_UTIL_H
|
||||
#define SHADER_UTIL_H
|
||||
|
||||
|
||||
|
||||
struct uniform_info
|
||||
{
|
||||
const char *name;
|
||||
GLuint size; /**< number of value[] elements: 1, 2, 3 or 4 */
|
||||
GLenum type; /**< GL_FLOAT, GL_FLOAT_VEC4, GL_INT, etc */
|
||||
GLfloat value[4];
|
||||
GLint location; /**< filled in by InitUniforms() */
|
||||
};
|
||||
|
||||
#define END_OF_UNIFORMS { NULL, 0, GL_NONE, { 0, 0, 0, 0 }, -1 }
|
||||
|
||||
|
||||
struct attrib_info
|
||||
{
|
||||
const char *name;
|
||||
GLuint size; /**< number of value[] elements: 1, 2, 3 or 4 */
|
||||
GLenum type; /**< GL_FLOAT, GL_FLOAT_VEC4, GL_INT, etc */
|
||||
GLint location;
|
||||
};
|
||||
|
||||
|
||||
extern GLboolean
|
||||
ShadersSupported(void);
|
||||
|
||||
extern GLuint
|
||||
CompileShaderText(GLenum shaderType, const char *text);
|
||||
|
||||
extern GLuint
|
||||
CompileShaderFile(GLenum shaderType, const char *filename);
|
||||
|
||||
extern GLuint
|
||||
LinkShaders(GLuint vertShader, GLuint fragShader);
|
||||
|
||||
extern GLboolean
|
||||
ValidateShaderProgram(GLuint program);
|
||||
|
||||
extern GLdouble
|
||||
GetShaderCompileTime(void);
|
||||
|
||||
extern GLdouble
|
||||
GetShaderLinkTime(void);
|
||||
|
||||
extern void
|
||||
SetUniformValues(GLuint program, struct uniform_info uniforms[]);
|
||||
|
||||
extern GLuint
|
||||
GetUniforms(GLuint program, struct uniform_info uniforms[]);
|
||||
|
||||
extern void
|
||||
PrintUniforms(const struct uniform_info uniforms[]);
|
||||
|
||||
extern GLuint
|
||||
GetAttribs(GLuint program, struct attrib_info attribs[]);
|
||||
|
||||
extern void
|
||||
PrintAttribs(const struct attrib_info attribs[]);
|
||||
|
||||
#endif /* SHADER_UTIL_H */
|
||||
Reference in New Issue
Block a user