added initial GL shader code

This commit is contained in:
jp9000 2013-10-09 15:48:16 -07:00
parent c301c9e1ef
commit fda2ee1147
8 changed files with 449 additions and 106 deletions

292
libobs-opengl/gl-shader.c Normal file
View File

@ -0,0 +1,292 @@
/******************************************************************************
Copyright (C) 2013 by Hugh Bailey <obs.jim@gmail.com>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program 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 General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/
#include <assert.h>
#include "gl-subsystem.h"
#include "gl-shaderparser.h"
static inline void shader_param_init(struct shader_param *param)
{
memset(param, 0, sizeof(struct shader_param));
}
static inline void shader_param_free(struct shader_param *param)
{
bfree(param->name);
da_free(param->cur_value);
da_free(param->def_value);
}
static void gl_get_program_info(GLuint program, char **error_string)
{
char *errors;
GLint info_len = 0;
GLsizei chars_written = 0;
glGetProgramiv(program, GL_INFO_LOG_LENGTH, &info_len);
if (!gl_success("glGetProgramiv") || !info_len)
return;
errors = bmalloc(info_len+1);
memset(errors, 0, info_len+1);
glGetProgramInfoLog(program, info_len, &chars_written, errors);
*error_string = errors;
}
static bool gl_add_param(struct gs_shader *shader, struct shader_var *var,
GLint *texture_id)
{
struct shader_param param = {0};
param.array_count = var->array_count;
param.name = bstrdup(var->name);
param.type = get_shader_param_type(var->type);
if (param.type == SHADER_PARAM_TEXTURE) {
param.sampler_id = var->gl_sampler_id;
param.texture_id = (*texture_id)++;
} else {
param.changed = true;
}
da_move(param.def_value, var->default_val);
da_copy(param.cur_value, param.def_value);
param.param = glGetUniformLocation(shader->program, param.name);
if (!gl_success("glGetUniformLocation"))
return false;
return true;
}
static inline bool gl_add_params(struct gs_shader *shader,
struct gl_shader_parser *glsp)
{
size_t i;
GLint tex_id = 0;
for (i = 0; i < glsp->parser.params.num; i++)
if (!gl_add_param(shader, glsp->parser.params.array+i, &tex_id))
return false;
return true;
}
static void gl_add_sampler(struct gs_shader *shader,
struct shader_sampler *sampler)
{
struct gs_sampler new_sampler = {0};
struct gs_sampler_info info;
shader_sampler_convert(sampler, &info);
convert_sampler_info(&new_sampler, &info);
da_push_back(shader->samplers, &new_sampler);
}
static inline void gl_add_samplers(struct gs_shader *shader,
struct gl_shader_parser *glsp)
{
size_t i;
for (i = 0; i < glsp->parser.samplers.num; i++) {
struct shader_sampler *sampler = glsp->parser.samplers.array+i;
gl_add_sampler(shader, sampler);
}
}
static bool gl_shader_init(struct gs_shader *shader,
struct gl_shader_parser *glsp,
const char *file, char **error_string)
{
GLenum type = convert_shader_type(shader->type);
int compiled = 0;
bool success = true;
shader->program = glCreateShaderProgramv(type, 1,
&glsp->gl_string.array);
gl_success("glCreateShaderProgramv");
if (!shader->program)
return false;
glGetProgramiv(shader->program, GL_VALIDATE_STATUS, &compiled);
if (!gl_success("glGetProgramiv"))
return false;
if (!compiled)
success = false;
gl_get_program_info(shader->program, error_string);
if (success)
success = gl_add_params(shader, glsp);
if (success)
gl_add_samplers(shader, glsp);
return success;
}
static struct gs_shader *shader_create(device_t device, enum shader_type type,
const char *shader_str, const char *file, char **error_string)
{
struct gs_shader *shader = bmalloc(sizeof(struct gs_shader));
struct gl_shader_parser glsp;
bool success = true;
memset(shader, 0, sizeof(struct gs_shader));
shader->type = type;
gl_shader_parser_init(&glsp);
if (!gl_shader_parse(&glsp, shader_str, file))
success = false;
else
success = gl_shader_init(shader, &glsp, file, error_string);
if (!success) {
shader_destroy(shader);
shader = NULL;
}
gl_shader_parser_free(&glsp);
return shader;
}
shader_t device_create_vertexshader(device_t device,
const char *shader, const char *file,
char **error_string)
{
return shader_create(device, SHADER_VERTEX, shader, file, error_string);
}
shader_t device_create_pixelshader(device_t device,
const char *shader, const char *file,
char **error_string)
{
return shader_create(device, SHADER_PIXEL, shader, file, error_string);
}
void shader_destroy(shader_t shader)
{
size_t i;
if (!shader)
return;
for (i = 0; i < shader->params.num; i++)
shader_param_free(shader->params.array+i);
if (shader->program) {
glDeleteProgram(shader->program);
gl_success("glDeleteProgram");
}
da_free(shader->samplers);
da_free(shader->params);
bfree(shader);
}
int shader_numparams(shader_t shader)
{
return (int)shader->params.num;
}
sparam_t shader_getparambyidx(shader_t shader, int param)
{
assert(param < shader->params.num);
return shader->params.array+param;
}
sparam_t shader_getparambyname(shader_t shader, const char *name)
{
size_t i;
for (i = 0; i < shader->params.num; i++) {
struct shader_param *param = shader->params.array+i;
if (strcmp(param->name, name) == 0)
return param;
}
return NULL;
}
void shader_getparaminfo(shader_t shader, sparam_t param,
struct shader_param_info *info)
{
info->type = param->type;
info->name = param->name;
}
sparam_t shader_getviewprojmatrix(shader_t shader)
{
return shader->viewproj;
}
sparam_t shader_getworldmatrix(shader_t shader)
{
return shader->world;
}
void shader_setbool(shader_t shader, sparam_t param, bool val)
{
}
void shader_setfloat(shader_t shader, sparam_t param, float val)
{
}
void shader_setint(shader_t shader, sparam_t param, int val)
{
}
void shader_setmatrix3(shader_t shader, sparam_t param,
const struct matrix3 *val)
{
}
void shader_setmatrix4(shader_t shader, sparam_t param,
const struct matrix4 *val)
{
}
void shader_setvec2(shader_t shader, sparam_t param,
const struct vec2 *val)
{
}
void shader_setvec3(shader_t shader, sparam_t param,
const struct vec3 *val)
{
}
void shader_setvec4(shader_t shader, sparam_t param,
const struct vec4 *val)
{
}
void shader_settexture(shader_t shader, sparam_t param, texture_t val)
{
}
void shader_setval(shader_t shader, sparam_t param, const void *val,
size_t size)
{
}
void shader_setdefault(shader_t shader, sparam_t param)
{
}

View File

@ -21,6 +21,32 @@
static void gl_write_function_contents(struct gl_shader_parser *glsp,
struct cf_token **p_token, const char *end);
static inline struct shader_var *sp_getparam(struct gl_shader_parser *glsp,
struct cf_token *token)
{
size_t i;
for (i = 0; i < glsp->parser.params.num; i++) {
struct shader_var *param = glsp->parser.params.array+i;
if (strref_cmp(&token->str, param->name) == 0)
return param;
}
return NULL;
}
static inline size_t sp_getsampler(struct gl_shader_parser *glsp,
struct cf_token *token)
{
size_t i;
for (i = 0; i < glsp->parser.samplers.num; i++) {
struct shader_sampler *sampler = glsp->parser.samplers.array+i;
if (strref_cmp(&token->str, sampler->name) == 0)
return i;
}
return -1;
}
static bool gl_write_type_n(struct gl_shader_parser *glsp,
const char *type, size_t len)
{
@ -251,8 +277,16 @@ static inline bool gl_write_texture_call(struct gl_shader_parser *glsp,
struct shader_var *var, const char *call)
{
struct cf_parser *cfp = &glsp->parser.cfp;
if (!go_to_token(cfp, ",", NULL))
return false;
size_t sampler_id = -1;
if (!next_token(cfp)) return false;
if (!token_is(cfp, "(")) return false;
if (!next_token(cfp)) return false;
sampler_id = sp_getsampler(glsp, cfp->cur_token);
if (sampler_id == -1) return false;
var->gl_sampler_id = sampler_id;
dstr_cat(&glsp->gl_string, call);
dstr_cat(&glsp->gl_string, "(");
@ -294,19 +328,6 @@ static bool gl_write_texture_code(struct gl_shader_parser *glsp,
return true;
}
static inline struct shader_var *sp_getparam(struct gl_shader_parser *glsp,
struct cf_token *token)
{
size_t i;
for (i = 0; i < glsp->parser.params.num; i++) {
struct shader_var *param = glsp->parser.params.array+i;
if (strref_cmp(&token->str, param->name) == 0)
return param;
}
return NULL;
}
static bool gl_write_intrinsic(struct gl_shader_parser *glsp,
struct cf_token **p_token)
{

View File

@ -30,6 +30,8 @@
struct gl_shader_parser {
struct dstr gl_string;
struct shader_parser parser;
DARRAY(uint32_t) texture_samplers;
};
static inline void gl_shader_parser_init(struct gl_shader_parser *glsp)

View File

@ -17,6 +17,17 @@
#include "gl-subsystem.h"
void convert_sampler_info(struct gs_sampler *sampler,
struct gs_sampler_info *info)
{
convert_filter(info->filter, &sampler->min_filter,
&sampler->mag_filter);
sampler->address_u = convert_address_mode(info->address_u);
sampler->address_v = convert_address_mode(info->address_v);
sampler->address_w = convert_address_mode(info->address_w);
sampler->max_anisotropy = info->max_anisotropy;
}
device_t device_create(struct gs_init_data *info)
{
struct gs_device *device = bmalloc(sizeof(struct gs_device));
@ -104,18 +115,6 @@ samplerstate_t device_create_samplerstate(device_t device,
{
}
shader_t device_create_vertexshader(device_t device,
const char *shader, const char *file,
char **error_string)
{
}
shader_t device_create_pixelshader(device_t device,
const char *shader, const char *file,
char **error_string)
{
}
vertbuffer_t device_create_vertexbuffer(device_t device,
struct vb_data *data, uint32_t flags)
{
@ -433,82 +432,3 @@ size_t indexbuffer_numindices(indexbuffer_t indexbuffer)
enum gs_index_type indexbuffer_gettype(indexbuffer_t indexbuffer)
{
}
void shader_destroy(shader_t shader)
{
}
int shader_numparams(shader_t shader)
{
}
sparam_t shader_getparambyidx(shader_t shader, int param)
{
}
sparam_t shader_getparambyname(shader_t shader, const char *name)
{
}
void shader_getparaminfo(shader_t shader, sparam_t param,
struct shader_param_info *info)
{
}
sparam_t shader_getviewprojmatrix(shader_t shader)
{
}
sparam_t shader_getworldmatrix(shader_t shader)
{
}
void shader_setbool(shader_t shader, sparam_t param, bool val)
{
}
void shader_setfloat(shader_t shader, sparam_t param, float val)
{
}
void shader_setint(shader_t shader, sparam_t param, int val)
{
}
void shader_setmatrix3(shader_t shader, sparam_t param,
const struct matrix3 *val)
{
}
void shader_setmatrix4(shader_t shader, sparam_t param,
const struct matrix4 *val)
{
}
void shader_setvec2(shader_t shader, sparam_t param,
const struct vec2 *val)
{
}
void shader_setvec3(shader_t shader, sparam_t param,
const struct vec3 *val)
{
}
void shader_setvec4(shader_t shader, sparam_t param,
const struct vec4 *val)
{
}
void shader_settexture(shader_t shader, sparam_t param, texture_t val)
{
}
void shader_setval(shader_t shader, sparam_t param, const void *val,
size_t size)
{
}
void shader_setdefault(shader_t shader, sparam_t param)
{
}

View File

@ -18,6 +18,7 @@
#ifndef GL_SUBSYSTEM_H
#define GL_SUBSYSTEM_H
#include "util/darray.h"
#include "graphics/graphics.h"
#include "glew/include/GL/glew.h"
#include "gl-helpers.h"
@ -85,6 +86,108 @@ static inline GLint convert_zstencil_format(enum gs_zstencil_format format)
}
}
static inline GLenum convert_shader_type(enum shader_type type)
{
switch (type) {
default:
case SHADER_VERTEX: return GL_VERTEX_SHADER;
case SHADER_PIXEL: return GL_FRAGMENT_SHADER;
}
}
static inline void convert_filter(enum gs_sample_filter filter,
GLint *min_filter, GLint *mag_filter)
{
switch (filter) {
case GS_FILTER_ANISOTROPIC:
*min_filter = GL_LINEAR_MIPMAP_LINEAR;
*mag_filter = GL_LINEAR;
break;
default:
case GS_FILTER_POINT:
*min_filter = GL_NEAREST_MIPMAP_NEAREST;
*mag_filter = GL_NEAREST;
break;
case GS_FILTER_LINEAR:
*min_filter = GL_LINEAR_MIPMAP_LINEAR;
*mag_filter = GL_LINEAR;
break;
case GS_FILTER_MIN_MAG_POINT_MIP_LINEAR:
*min_filter = GL_NEAREST_MIPMAP_LINEAR;
*mag_filter = GL_NEAREST;
break;
case GS_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT:
*min_filter = GL_NEAREST_MIPMAP_NEAREST;
*mag_filter = GL_LINEAR;
break;
case GS_FILTER_MIN_POINT_MAG_MIP_LINEAR:
*min_filter = GL_NEAREST_MIPMAP_LINEAR;
*mag_filter = GL_LINEAR;
break;
case GS_FILTER_MIN_LINEAR_MAG_MIP_POINT:
*min_filter = GL_LINEAR_MIPMAP_NEAREST;
*mag_filter = GL_NEAREST;
break;
case GS_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR:
*min_filter = GL_LINEAR_MIPMAP_LINEAR;
*mag_filter = GL_NEAREST;
break;
case GS_FILTER_MIN_MAG_LINEAR_MIP_POINT:
*min_filter = GL_LINEAR_MIPMAP_NEAREST;
*mag_filter = GL_LINEAR;
break;
}
}
static inline GLint convert_address_mode(enum gs_address_mode mode)
{
switch (mode) {
default:
case GS_ADDRESS_WRAP: return GL_REPEAT;
case GS_ADDRESS_CLAMP: return GL_CLAMP;
case GS_ADDRESS_MIRROR: return GL_MIRRORED_REPEAT;
case GS_ADDRESS_BORDER: return GL_CLAMP_TO_BORDER;
case GS_ADDRESS_MIRRORONCE: return GL_MIRROR_CLAMP_EXT;
}
}
extern void convert_sampler_info(struct gs_sampler *sampler,
struct gs_sampler_info *info);
struct gs_sampler {
GLint min_filter;
GLint mag_filter;
GLint address_u;
GLint address_v;
GLint address_w;
GLint max_anisotropy;
};
struct shader_param {
char *name;
enum shader_param_type type;
GLint param;
GLint texture_id;
size_t sampler_id;
int array_count;
DARRAY(uint8_t) cur_value;
DARRAY(uint8_t) def_value;
bool changed;
};
struct gs_shader {
device_t device;
enum shader_type type;
GLuint program;
struct shader_param *viewproj;
struct shader_param *world;
DARRAY(struct gs_sampler) samplers;
DARRAY(struct shader_param) params;
};
struct gs_texture {
device_t device;
enum gs_texture_type type;

View File

@ -49,6 +49,7 @@ struct shader_var {
char *mapping;
enum shader_var_type var_type;
int array_count;
size_t gl_sampler_id; /* optional: used/parsed by GL */
DARRAY(uint8_t) default_val;
};

View File

@ -162,6 +162,7 @@
</ItemGroup>
<ItemGroup>
<ClCompile Include="..\..\..\libobs-opengl\gl-helpers.c" />
<ClCompile Include="..\..\..\libobs-opengl\gl-shader.c" />
<ClCompile Include="..\..\..\libobs-opengl\gl-shaderparser.c" />
<ClCompile Include="..\..\..\libobs-opengl\gl-subsystem.c" />
<ClCompile Include="..\..\..\libobs-opengl\gl-texture2d.c" />

View File

@ -47,5 +47,8 @@
<ClCompile Include="..\..\..\libobs-opengl\gl-shaderparser.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\..\..\libobs-opengl\gl-shader.c">
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup>
</Project>