jp9000/obs-studio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

added first GLSL code, moved some graphics functions around, and adjusted some existing shader parser code

Browse Source
This commit is contained in:
jp9000
2013-10-06 18:29:29 -07:00
parent fecb5578e3
commit f9d1a4b9ed
9 changed files with 404 additions and 63 deletions
Download Patch File Download Diff File Expand all files Collapse all files

240
libobs-opengl/gl-shaderparser.c Normal file
View File

@@ -0,0 +1,240 @@
/******************************************************************************
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 "gl-subsystem.h"
#include "gl-shaderparser.h"
static void gl_write_type_n(struct gl_shader_parser *glsp,
const char *type, size_t len)
{
if (astrcmp_n(type, "float2", len) == 0)
dstr_cat(&glsp->gl_string, "vec2");
else if (astrcmp_n(type, "float3", len) == 0)
dstr_cat(&glsp->gl_string, "vec3");
else if (astrcmp_n(type, "float4", len) == 0)
dstr_cat(&glsp->gl_string, "vec4");
else if (astrcmp_n(type, "float3x3", len) == 0)
dstr_cat(&glsp->gl_string, "mat3x3");
else if (astrcmp_n(type, "float3x4", len) == 0)
dstr_cat(&glsp->gl_string, "mat3x4");
else if (astrcmp_n(type, "float4x4", len) == 0)
dstr_cat(&glsp->gl_string, "mat4x4");
else if (astrcmp_n(type, "texture2d", len) == 0)
dstr_cat(&glsp->gl_string, "sampler2D");
else if (astrcmp_n(type, "texture3d", len) == 0)
dstr_cat(&glsp->gl_string, "sampler3D");
else if (astrcmp_n(type, "texture_cube", len) == 0)
dstr_cat(&glsp->gl_string, "samplerCube");
else
dstr_ncat(&glsp->gl_string, type, len);
}
static inline void gl_write_type(struct gl_shader_parser *glsp,
const char *type)
{
gl_write_type_n(glsp, type, strlen(type));
}
static inline void gl_write_type_token(struct gl_shader_parser *glsp,
struct cf_token *token)
{
gl_write_type_n(glsp, token->str.array, token->str.len);
}
static void gl_write_var(struct gl_shader_parser *glsp, struct shader_var *var)
{
if (var->var_type == SHADER_VAR_UNIFORM)
dstr_cat(&glsp->gl_string, "uniform ");
else if (var->var_type == SHADER_VAR_CONST)
dstr_cat(&glsp->gl_string, "const ");
gl_write_type(glsp, var->type);
dstr_cat(&glsp->gl_string, " ");
dstr_cat(&glsp->gl_string, var->name);
dstr_cat(&glsp->gl_string, ";\n");
}
static inline void gl_write_params(struct gl_shader_parser *glsp)
{
size_t i;
for (i = 0; i < glsp->parser.params.num; i++) {
struct shader_var *var = glsp->parser.params.array+i;
gl_write_var(glsp, var);
}
dstr_cat(&glsp->gl_string, "\n");
}
static void gl_write_storage_var(struct gl_shader_parser *glsp,
struct shader_var *var, const char *storage,
const char *prefix);
/* unwraps a structure that's used for input/output */
static void gl_unwrap_storage_struct(struct gl_shader_parser *glsp,
struct shader_struct *st, const char *storage,
const char *prefix)
{
struct dstr prefix_str;
size_t i;
dstr_init(&prefix_str);
if (prefix)
dstr_copy(&prefix_str, prefix);
dstr_cat(&prefix_str, st->name);
dstr_cat(&prefix_str, "_");
for (i = 0; i < st->vars.num; i++) {
struct shader_var *st_var = st->vars.array+i;
gl_write_storage_var(glsp, st_var, storage, prefix_str.array);
}
dstr_free(&prefix_str);
}
static void gl_write_storage_var(struct gl_shader_parser *glsp,
struct shader_var *var, const char *storage, const char *prefix)
{
struct shader_struct *st = shader_parser_getstruct(&glsp->parser,
var->type);
if (st) {
gl_unwrap_storage_struct(glsp, st, storage, prefix);
} else {
if (storage) {
dstr_cat(&glsp->gl_string, storage);
dstr_cat(&glsp->gl_string, " ");
}
gl_write_type(glsp, var->type);
dstr_cat(&glsp->gl_string, " ");
if (prefix)
dstr_cat(&glsp->gl_string, prefix);
dstr_cat(&glsp->gl_string, var->name);
dstr_cat(&glsp->gl_string, ";\n");
}
}
static inline void gl_write_inputs(struct gl_shader_parser *glsp,
struct shader_func *main)
{
size_t i;
for (i = 0; i < main->params.num; i++) {
struct shader_var *var = main->params.array+i;
gl_write_storage_var(glsp, var, "in", "in_");
}
}
static void gl_write_outputs(struct gl_shader_parser *glsp,
struct shader_func *main)
{
struct shader_var var;
shader_var_init(&var);
var.type = bstrdup(main->return_type);
var.name = bstrdup("return_val");
if (main->return_mapping)
var.mapping = bstrdup(main->return_mapping);
gl_write_storage_var(glsp, &var, "out", "out_");
shader_var_free(&var);
}
static void gl_write_struct(struct gl_shader_parser *glsp,
struct shader_struct *st)
{
size_t i;
dstr_cat(&glsp->gl_string, "struct ");
dstr_cat(&glsp->gl_string, st->name);
dstr_cat(&glsp->gl_string, " {\n");
for (i = 0; i < st->vars.num; i++) {
struct shader_var *var = st->vars.array+i;
dstr_cat(&glsp->gl_string, "\t");
gl_write_var(glsp, var);
}
dstr_cat(&glsp->gl_string, "};\n\n");
}
static inline void gl_write_structs(struct gl_shader_parser *glsp)
{
size_t i;
for (i = 0; i < glsp->parser.structs.num; i++) {
struct shader_struct *st = glsp->parser.structs.array+i;
gl_write_struct(glsp, st);
}
}
/*
* NOTE: HLSL-> GLSL intrinsic conversions
* atan2 -> atan
* clip -> (unsupported)
* ddx -> dFdx
* ddy -> dFdy
* fmod -> (unsupported)
* frac -> fract
* lerp -> mix
* lit -> (unsupported)
* log10 -> (unsupported)
* mul -> (change to operator)
* rsqrt -> inversesqrt
* saturate -> (use clamp)
* tex* -> texture
* tex*grad -> textureGrad
* tex*lod -> textureLod
* tex*bias -> (use optional 'bias' value)
* tex*proj -> textureProj
*
* All else can be left as-is
*/
static void gl_write_functions(struct gl_shader_parser *glsp)
{
}
static bool gl_shader_buildstring(struct gl_shader_parser *glsp)
{
struct shader_func *main = shader_parser_getfunc(&glsp->parser, "main");
if (!main) {
blog(LOG_ERROR, "function 'main' not found");
return false;
}
dstr_copy(&glsp->gl_string, "#version 140\n\n");
gl_write_params(glsp);
gl_write_inputs(glsp, main);
gl_write_outputs(glsp, main);
gl_write_structs(glsp);
gl_write_functions(glsp);
// gl_write_main(glsp);
return true;
}
bool gl_shader_parse(struct gl_shader_parser *glsp,
const char *shader_str, const char *file)
{
bool success = shader_parse(&glsp->parser, shader_str, file);
char *str = shader_parser_geterrors(&glsp->parser);
if (str) {
blog(LOG_WARNING, "Shader parser errors/warnings:\n%s\n", str);
bfree(str);
}
return success;
}

51
libobs-opengl/gl-shaderparser.h Normal file
View File

@@ -0,0 +1,51 @@
/******************************************************************************
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/>.
******************************************************************************/
#ifndef GL_SHADER_PARSER_H
#define GL_SHADER_PARSER_H
/*
* Parses shaders into GLSL. Shaders are almost identical to HLSL
* model 5 so it requires quite a bit of tweaking to convert correctly.
* Takes the parsed shader data, and builds a GLSL string out of it.
*/
#include "util/dstr.h"
#include "graphics/shader-parser.h"
struct gl_shader_parser {
struct dstr gl_string;
struct dstr gl_main_func;
struct shader_parser parser;
};
static inline void gl_shader_parser_init(struct gl_shader_parser *glsp)
{
shader_parser_init(&glsp->parser);
dstr_init(&glsp->gl_string);
}
static inline void gl_shader_parser_free(struct gl_shader_parser *glsp)
{
dstr_free(&glsp->gl_string);
shader_parser_free(&glsp->parser);
}
extern bool gl_shader_parse(struct gl_shader_parser *glsp,
const char *shader_str, const char *file);
#endif

2
libobs-opengl/gl-texturecube.c
View File

@@ -62,6 +62,8 @@ texture_t device_create_cubetexture(device_t device, uint32_t size,
tex->base.format = color_format;
tex->base.gl_format = convert_gs_format(color_format);
tex->base.gl_internal_format = convert_gs_internal_format(color_format);
tex->base.is_render_target = flags & GS_RENDERTARGET;
tex->base.gen_mipmaps = flags & GS_BUILDMIPMAPS;
tex->size = size;
if (!gl_gen_textures(1, &tex->base.texture))