GLuint Shader::Load(const String& vertSrc, const String& fragSrc)
{
const char* vertexSource = vertSrc.c_str();
const char* fragmentSource = fragSrc.c_str();
GLuint program = glCreateProgram();
GLuint vertex = glCreateShader(GL_VERTEX_SHADER);
GLuint fragment = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(vertex, 1, &vertexSource, NULL);
glCompileShader(vertex);
GLint result;
glGetShaderiv(vertex, GL_COMPILE_STATUS, &result);
if (result == GL_FALSE)
{
GLint length;
glGetShaderiv(vertex, GL_INFO_LOG_LENGTH, &length);
std::vector<char> error(length);
glGetShaderInfoLog(vertex, length, &length, &error[0]);
SP_ERROR("Failed to compile vertex shader!");
SP_ERROR(&error[0]);
SP_ASSERT(false, "Failed to compile vertex shader!");
glDeleteShader(vertex);
return 0;
}
glShaderSource(fragment, 1, &fragmentSource, NULL);
glCompileShader(fragment);
glGetShaderiv(fragment, GL_COMPILE_STATUS, &result);
if (result == GL_FALSE)
{
GLint length;
glGetShaderiv(fragment, GL_INFO_LOG_LENGTH, &length);
std::vector<char> error(length);
glGetShaderInfoLog(fragment, length, &length, &error[0]);
SP_ERROR("Failed to compile fragment shader!");
SP_ERROR(&error[0]);
SP_ASSERT(false, "Failed to compile fragment shader!");
glDeleteShader(fragment);
return 0;
}
glAttachShader(program, vertex);
glAttachShader(program, fragment);
glLinkProgram(program);
glValidateProgram(program);
glDeleteShader(vertex);
glDeleteShader(fragment);
return program;
}
GLint Shader::GetUniformLocation(const String& name)
{
GLint result = glGetUniformLocation(m_ShaderID, name.c_str());
if (result == -1)
SP_ERROR(m_Name, ": could not find uniform ", name, " in shader!");
return result;
}
bool log_gl_call(const char* function, const char* file, int line)
{
GLenum error = glGetError();
if (error != GL_NO_ERROR)
{
SP_ERROR("[OpenGL Error] (", error, "): ", function, " ", file, ":", line);
return false;
}
return true;
}
void Shader::SetUniform(const String& name, byte* data)
{
ShaderUniformDeclaration* uniform = FindUniformDeclaration(name);
if (!uniform)
{
SP_ERROR("Cannot find uniform in ", m_Name, " shader with name '", name, "'");
return;
}
ResolveAndSetUniform(uniform, data, 0);
}
//-----------------------------------------------------------------------------
axiom_node_t *
sp_make_MTOM_node20(
const axutil_env_t *env,
axutil_stream_t *st,
char *header_blob,
axis2_char_t *el_name,
axis2_char_t *content_type,
axis2_char_t *ns_prefix,
axis2_char_t *ns_uri)
{
axiom_node_t *resp_om_node = NULL;
int data_len = 0;
char *bin_data = sp_load_binary_file(env, header_blob, st, &data_len);
if (NULL == bin_data)
{
SP_ERROR(env, SP_USER_ERR_DATA_LOAD);
}
else
{
axiom_element_t *resp_om_ele = NULL;
axiom_data_handler_t *data_handler = NULL;
axiom_node_t *data_om_node = NULL;
axiom_text_t *data_text = NULL;
axiom_namespace_t *ns = axiom_namespace_create(env, ns_uri, ns_prefix);
resp_om_ele =
axiom_element_create (env, NULL, el_name, ns, &resp_om_node);
data_handler =
axiom_data_handler_create(env, NULL, content_type);
axiom_data_handler_set_binary_data
(data_handler, env, bin_data, data_len);
data_text =
axiom_text_create_with_data_handler
(env, resp_om_node, data_handler, &data_om_node);
axiom_text_set_optimize(data_text, env, AXIS2_TRUE);
}
// Note: The buffer 'bin_data' gets freed when
// axiom_data_handler_free is called, and it in turn gets called
// from axiom_text_free.
// That should get called when the resp_om_node gets freed.
// Hopefully the service framework does this at some point.
return resp_om_node;
}
void ShaderManager::Reload(const String& name)
{
for (uint i = 0; i < s_Shaders.size(); i++)
{
if (s_Shaders[i]->GetName() == name)
{
String path = s_Shaders[i]->GetFilePath();
String error;
if (!API::Shader::TryCompileFromFile(path, error))
{
SP_ERROR(error);
}
else
{
s_Shaders[i]->~Shader();
s_Shaders[i] = API::Shader::CreateFromFile(name, path, s_Shaders[i]);
SP_INFO("Reloaded shader: " + name);
}
return;
}
}
SP_WARN("Could not find '", name, "' shader to reload.");
}
//-----------------------------------------------------------------------------
axiom_node_t *
sp_build_response20(
const axutil_env_t *env,
const sp_props *props,
axutil_stream_t *st)
{
char tmpBuf[255];
axiom_node_t *return_node = NULL;
hh_values hh;
sp_initHttpHeaderStruct(&hh);
char header_buf[2560];
if (sp_load_header_blob(env, st, header_buf, 2560) < 0)
{
// TODO: Could allocate a bigger buffer, copy chars, etc.
// In practice we never expect the headers to be that big, or if
// it does come up then something is wrong.
SP_ERROR(env, SP_USER_ERR_CONTENTHEADERS);
return NULL;
}
sp_parseHttpHeaders_buf(env, &hh, header_buf);
char *contentTypeStr = hh.values[SP_HH_CONTENTTYPE];
if ( NULL == contentTypeStr)
{
sp_freeHttpHeaders(env, &hh);
SP_ERROR(env, SP_USER_ERR_CONTENTHEADERS);
return NULL;
}
switch(rp_get_contentType(contentTypeStr))
{
case SP_RESP_XML_TYPE:
case SP_RESP_APP_SEXML_TYPE:
return_node = sp_process_xml_st(env, st, NULL);
break;
case SP_RESP_MIXED_TYPE:
// A mixed type response generally signifies a coverage response.
// TODO: check that we really do have a coverage!
return_node = sp_process_coverage20(env, contentTypeStr, st);
break;
case SP_RESP_TIFF_TYPE:
return_node = sp_process_tiff20(env, st, &hh);
break;
default:
SP_ERROR(env, SP_USER_ERR_CONTENTTYPE);
rp_log_error(env,
"*** S2P(%s:%d): Unrecognised Content-type: %s\n",
__FILE__, __LINE__,
contentTypeStr);
if (rp_getDebugMode(env, props))
{
sp_dump_bad_content(env, contentTypeStr, st, header_buf);
}
}
sp_freeHttpHeaders(env, &hh);
return return_node;
}
