void
piglit_init(int argc, char **argv)
{
bool piglit_pass = true;
GLuint vs, fs, prog;
GLint loc;
float vf[] = { 1.0, 2.0, 3.0 };
double vd[] = { 1.0, 2.0, 3.0, 4.0, 5.0};
piglit_require_extension("GL_ARB_gpu_shader_fp64");
vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vs_text);
fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fs_text);
prog = piglit_link_simple_program(vs, fs);
glUseProgram(prog);
// Setting different type should fail
loc = glGetUniformLocation(prog, "d");
glUniform1i(loc, 3);
piglit_pass = piglit_pass
&& piglit_check_gl_error(GL_INVALID_OPERATION);
glUniform1f(loc, 3.0);
piglit_pass = piglit_pass
&& piglit_check_gl_error(GL_INVALID_OPERATION);
glUniform1d(loc, 3.0);
piglit_pass = piglit_pass && piglit_check_gl_error(GL_NO_ERROR);
loc = glGetUniformLocation(prog, "v");
glUniform3fv(loc, 1, vf);
piglit_pass = piglit_pass
&& piglit_check_gl_error(GL_INVALID_OPERATION);
glUniform3d(loc, vd[0], vd[1], vd[2]);
piglit_pass = piglit_pass && piglit_check_gl_error(GL_NO_ERROR);
// Setting different size should fail
loc = glGetUniformLocation(prog, "v");
glUniform2d(loc, vd[0], vd[1]);
piglit_pass = piglit_pass
&& piglit_check_gl_error(GL_INVALID_OPERATION);
glUniform4d(loc, vd[0], vd[1], vd[2], vd[3]);
piglit_pass = piglit_pass
&& piglit_check_gl_error(GL_INVALID_OPERATION);
glUniform3d(loc, vd[0], vd[1], vd[2]);
piglit_pass = piglit_pass && piglit_check_gl_error(GL_NO_ERROR);
// Special case for booleans
loc = glGetUniformLocation(prog, "b");
glUniform1d(loc, 1.0);
piglit_pass = piglit_pass
&& piglit_check_gl_error(GL_INVALID_OPERATION);
glUniform1f(loc, 1.0);
piglit_pass = piglit_pass
&& piglit_check_gl_error(GL_NO_ERROR);
piglit_report_result(piglit_pass ? PIGLIT_PASS : PIGLIT_FAIL);
}
void loadTexture(int n, GLuint texture, GLint sampler, int texUnit, const char *filename)
{
FREE_IMAGE_FORMAT imageFormat = FreeImage_GetFileType(filename, 0);
FIBITMAP *bitmap = FreeImage_Load(imageFormat, filename, 0);
unsigned int width = FreeImage_GetWidth(bitmap);
unsigned int height = FreeImage_GetHeight(bitmap);
unsigned char *data = FreeImage_GetBits(bitmap);
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
if (texUnit == 0)
{
glActiveTexture(GL_TEXTURE0);
g_texUnit0 = true;
}
else
{
glActiveTexture(GL_TEXTURE1);
g_texUnit1 = true;
}
glBindTexture(GL_TEXTURE_2D, texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
glUniform1d(sampler, texUnit);
glClear(GL_COLOR_BUFFER_BIT);
if (g_texUnit0 && g_texUnit1)
{
glDrawArrays(GL_TRIANGLE_STRIP, 0, n);
}
FreeImage_Unload(bitmap);
}
void GL_LINES_CanopyFractal::drawRecursive(CanopyNode *node, glm::dmat4 pos, glm::dmat4 scale) {
glm::dvec3 eulerAngles(0.0, 0.0, (double)node->angle_degrees);
glm::dquat Quaternion(eulerAngles);
glm::dmat4 rotation = glm::mat4_cast(Quaternion);
pos = pos * rotation;
glm::dmat4 model = pos * scale;
glm::dmat4 MVP = Projection * View * model;
GLfloat mytime = time(NULL);
glUseProgram(programID);
glUniformMatrix4dv(matrixID, 1, GL_FALSE, &MVP[0][0]);
glUniform1d(timeID, mytime);
glEnableVertexAttribArray(0);
glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
glVertexAttribPointer(0,
3,
GL_FLOAT,
GL_FALSE,
0,
(void*)0);
glDrawArrays(GL_LINES, 0, 2);
glDisableVertexAttribArray(0);
glm::dmat4 translation = glm::translate(glm::dmat4(1.0), glm::dvec3(0.0, (double)node->length, 0.0));
glm::dmat4 s = glm::scale(glm::dmat4(1.0), glm::dvec3(0.5, 0.5, 0.5));
scale = scale * s;
pos = pos * translation;
if(node->rnode) {
drawRecursive(node->rnode, pos, scale);
}
if(node->lnode) {
drawRecursive(node->lnode, pos, scale);
}
}
void Shader::SendDouble(int location, double value) const
{
if (location == -1)
return;
if (glProgramUniform1d)
glProgramUniform1d(m_program, location, value);
else
{
OpenGL::BindProgram(m_program);
glUniform1d(location, value);
}
}
void ProgramManager::setUniform(const char *name, LFLOAT val)
{
int loc = getUniformLocation(name);
if (loc >= 0)
{
#ifdef IADOUBLE
glUniform1d(loc, val);
#else
glUniform1f(loc, val);
#endif
}
else {
cerr << "Uniform: " << name << " is not found." << endl;
}
}
void Mandlebrot::render(const int iter, const float aspect_ratio,
const double cx, const double cy,
const double cur_scale) {
glUseProgram(programID);
glUniform1i(u_iter, iter);
glUniform1f(u_asp, aspect_ratio);
#if VERSION == 330
glUniform2f(u_center, float(cx), float(cy));
glUniform1f(u_scale, float(cur_scale));
#else
glUniform2d(u_center, cx, cy);
glUniform1d(u_scale, cur_scale);
#endif
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_1D, TextureID);
glUniform1i(TextureLoc, 0);
glUniformMatrix4fv(MatrixID, 1, GL_FALSE, &Projection[0][0]);
glBindVertexArray(VertexArrayID);
glEnableVertexAttribArray(0);
glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, (void*)0);
glEnableVertexAttribArray(1);
glBindBuffer(GL_ARRAY_BUFFER, uvbuffer);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, (void*)0);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glDisableVertexAttribArray(0);
glDisableVertexAttribArray(1);
}
void GLProgram::setDoubleUniform(std::string name, double value) {
glUniform1d(this->uniforms[name], value);
}
void setUniform (int loc, F64 v) { if (loc >= 0) glUniform1d(loc, v); }
void Uniform::loadDefaultCallbacks()
{
if (setCallbacks["int"] != nullptr) return;
setCallbacks["int"] = [](void* val, Uniform& u){
glUniform1i(u.getLocation(), *static_cast<int*>(val));
};
setCallbacks["uint"] = [](void* val, Uniform& u){
glUniform1i(u.getLocation(), *static_cast<unsigned int*>(val));
};
setCallbacks["float"] = [](void* val, Uniform& u){
glUniform1f(u.getLocation(), *static_cast<float*>(val));
};
setCallbacks["double"] = [](void* val, Uniform& u){
glUniform1d(u.getLocation(), *static_cast<double*>(val));
};
setCallbacks["bool"] = [](void* val, Uniform& u){
glUniform1i(u.getLocation(), *static_cast<bool*>(val));
};
setCallbacks["sampler1D"] = [](void* val, Uniform& u){
glUniform1i(u.getLocation(), *static_cast<int*>(val));
};
setCallbacks["sampler2D"] = [](void* val, Uniform& u){
glUniform1i(u.getLocation(), *static_cast<int*>(val));
};
setCallbacks["sampler3D"] = [](void* val, Uniform& u){
glUniform1i(u.getLocation(), *static_cast<int*>(val));
};
setCallbacks["vec2"] = [](void* val, Uniform& u){
glUniform2f(u.getLocation(), static_cast<Vector2*>(val)->x, static_cast<Vector2*>(val)->y);
};
setCallbacks["vec3"] = [](void* val, Uniform& u){
Vector3* v = static_cast<Vector3*>(val);
glUniform3f(u.getLocation(), v->x, v->y, v->z);
};
setCallbacks["vec4"] = [](void* val, Uniform& u){
glUniform4f(u.getLocation(), static_cast<Vector4*>(val)->x, static_cast<Vector4*>(val)->y, static_cast<Vector4*>(val)->z, static_cast<Vector4*>(val)->w);
};
setCallbacks["mat4"] = [](void* val, Uniform& u){
//std::cout << v << std::endl;
glUniformMatrix4fv(u.getLocation(), 1, GL_TRUE, static_cast<Matrix4*>(val)->toArray());
};
setCallbacks["BaseLight"] = [](void* val, Uniform& u){
BaseLight* base = static_cast<BaseLight*>(val);
if (u.hasChild("intensity")) u.getChild("intensity")->setValue(base->getIntensity());
if (u.hasChild("color")) u.getChild("color")->setValue(&base->getColor());
};
setCallbacks["DirectionalLight"] = [](void* val, Uniform& u){
DirectionalLight* dir = static_cast<DirectionalLight*>(val);
if (u.hasChild("base")) u.getChild("base")->setValue(static_cast<BaseLight*>(dir));
if (u.hasChild("direction")) u.getChild("direction")->setValue(dir->getDirection());
};
setCallbacks["PointLight"] = [](void* val, Uniform& u){
PointLight* poi = static_cast<PointLight*>(val);
if (u.hasChild("base")) u.getChild("base")->setValue(static_cast<BaseLight*>(poi));
if (u.hasChild("constant")) u.getChild("constant")->setValue(poi->getConstant());
if (u.hasChild("linear")) u.getChild("linear")->setValue(poi->getLinear());
if (u.hasChild("exponent")) u.getChild("exponent")->setValue(poi->getExponent());
if (u.hasChild("position")) u.getChild("position")->setValue(poi->getTransform()->getWorldPosition());
if (u.hasChild("range")) u.getChild("range")->setValue(poi->getRange());
};
setCallbacks["SpotLight"] = [](void* val, Uniform& u){
SpotLight* spot = static_cast<SpotLight*>(val);
if (u.hasChild("pointLight")) u.getChild("pointLight")->setValue(static_cast<PointLight*>(spot));
if (u.hasChild("direction")) u.getChild("direction")->setValue(&spot->getDirection());
if (u.hasChild("cutoff")) u.getChild("cutoff")->setValue(spot->getCutoff());
};
}
void Shader::uniform(std::string attributeName, double value)
{
glUniform1d(getUniformLocation(attributeName), value);
}
void Scene::Pipeline(Sprite* sprite, float dt)
{
//Init model matrix
mat44 model;
model.SetIdentity();
//Setting Perspection
mat44 projection;
if (sprite->GetProjectionType() == PERSPECTIVE)
projection = mat44::Perspective(m_fovy, aspectRatio, m_zNear, m_zFar);
else
projection = mat44::Ortho(-m_width / 2.f, m_width / 2.f, -m_height / 2.f, m_height / 2.f, m_zNear, m_zFar);
//Setting Camera
mat44 camera = mat44::LookAt(
vec3(m_camera),
vec3(m_camera.x, m_camera.y, 0),
vec3(cosf(Math::DegToRad((m_camera.w + 90.f))),
sinf(Math::DegToRad((m_camera.w + 90.f))),
0));
//Transform model mat
model = model * mat44::Scale(sprite->GetScale())
* mat44::Rotate(Math::DegToRad(sprite->GetRotation()), vec3(.0f, .0f, 1.f))
* mat44::Translate(sprite->GetPosition());
glUniformMatrix4fv(m_GSM->GetGLManager()->GetUnifrom(MODEL), 1, GL_FALSE, &model.m_member[0][0]);
glUniformMatrix4fv(m_GSM->GetGLManager()->GetUnifrom(VIEWPORT), 1, GL_FALSE, &camera.m_member[0][0]);
glUniformMatrix4fv(m_GSM->GetGLManager()->GetUnifrom(PROJECTION), 1, GL_FALSE, &projection.m_member[0][0]);
// Refresh the animation scene
if (sprite->GetPlayToggle())
{
if (sprite->GetDividedSpeed() <= sprite->GetTimer().GetElapsedTime())
{
// If current scene is over, refresh
if (sprite->GetCurrentScene() + sprite->GetDividedFrame() >= 1)
sprite->SetCurrentScene(0);
else
sprite->SetCurrentScene(sprite->GetCurrentScene() + sprite->GetDividedFrame());
sprite->GetTimer().StartTime();
}
}
// Animation pipeline
m_animation.SetIdentity();
m_animation = m_animation * mat44::Scale(vec3(sprite->GetDividedFrame(), 1.f));
m_animation = m_animation * mat44::Translate(vec3(sprite->GetCurrentScene(), 0.f));
glUniformMatrix4fv(m_GSM->GetGLManager()->GetUnifrom(UV), 1, GL_FALSE, &m_animation.m_member[0][0]);
if (sprite->HasEffect())
{
// Wave effect part...
auto wave_effect = sprite->GetEffect(WAVE);
if (wave_effect && wave_effect->GetWaveToggle())
{
m_phase.x -= wave_effect->GetWavePhase().x * dt;
m_phase.y += wave_effect->GetWavePhase().y * dt;
if (m_phase.x < -1.f || m_phase.y > 1.f)
m_phase.x = m_phase.y = 0.f;
glUniform1d(m_GSM->GetGLManager()->GetUnifrom(WAVE_TOGGLE), sprite->GetEffect(WAVE)->GetWaveToggle());
}
auto sobel_effect = sprite->GetEffect(SOBEL);
if (sobel_effect && sobel_effect->GetSobelToggle())
{
glUniform1d(m_GSM->GetGLManager()->GetUnifrom(SOBEL_TOGGLE), sprite->GetEffect(SOBEL)->GetSobelToggle());
glUniform1f(m_GSM->GetGLManager()->GetUnifrom(SOBEL_AMOUNT), sprite->GetEffect(SOBEL)->GetSobelAmount());
}
auto inverse_effect = sprite->GetEffect(INVERSE);
if (inverse_effect && inverse_effect->GetInverseToggle())
{
glUniform1d(m_GSM->GetGLManager()->GetUnifrom(INVERSE_TOGGLE), sprite->GetEffect(INVERSE)->GetInverseToggle());
}
auto blur_effect = sprite->GetEffect(BLUR);
if (blur_effect && blur_effect->GetBlurToggle())
{
glUniform1d(m_GSM->GetGLManager()->GetUnifrom(BLUR_TOGGLE), sprite->GetEffect(BLUR)->GetBlurToggle());
glUniform1f(m_GSM->GetGLManager()->GetUnifrom(BLUR_AMOUNT), sprite->GetEffect(BLUR)->GetBlurAmount());
}
}
else
{
glUniform1d(m_GSM->GetGLManager()->GetUnifrom(WAVE_TOGGLE), sprite->HasEffect());
glUniform1d(m_GSM->GetGLManager()->GetUnifrom(SOBEL_TOGGLE), sprite->HasEffect());
glUniform1d(m_GSM->GetGLManager()->GetUnifrom(BLUR_TOGGLE), sprite->HasEffect());
glUniform1d(m_GSM->GetGLManager()->GetUnifrom(INVERSE_TOGGLE), sprite->HasEffect());
}
glUniform2f(m_GSM->GetGLManager()->GetUnifrom(WAVE_PHASE), m_phase.x, m_phase.y);
}
void Shader::SetUniform1d(const GLchar* name, int value){
glUniform1d(getUniformLocation(name), value);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL40_nglUniform1d(JNIEnv *__env, jclass clazz, jint location, jdouble x, jlong __functionAddress) {
glUniform1dPROC glUniform1d = (glUniform1dPROC)(intptr_t)__functionAddress;
UNUSED_PARAMS(__env, clazz)
glUniform1d(location, x);
}
static void uniformFunc(GLint loc, double val)
{
return glUniform1d(loc, val);
}
void kore::BindUniform::doExecute(void) const {
if(!_componentUniform) {
Log::getInstance()->write("[ERROR] Uniform binding undefined");
return;
}
GLerror::gl_ErrorCheckStart();
_renderManager->
useShaderProgram(_shaderUniform->shader->getProgramLocation());
switch (_componentUniform->type) {
case GL_FLOAT:
glUniform1fv(_shaderUniform->location, _componentUniform->size,
static_cast<GLfloat*>(_componentUniform->data));
break;
case GL_FLOAT_VEC2:
glUniform2fv(_shaderUniform->location, _componentUniform->size,
static_cast<GLfloat*>(_componentUniform->data));
break;
case GL_FLOAT_VEC3:
glUniform3fv(_shaderUniform->location, _componentUniform->size,
static_cast<GLfloat*>(_componentUniform->data));
break;
case GL_FLOAT_VEC4:
glUniform4fv(_shaderUniform->location, _componentUniform->size,
static_cast<GLfloat*>(_componentUniform->data));
break;
case GL_DOUBLE:
glUniform1d(_shaderUniform->location,
*static_cast<GLdouble*>(_componentUniform->data));
break;
case GL_DOUBLE_VEC2:
glUniform2dv(_shaderUniform->location, _componentUniform->size,
static_cast<GLdouble*>(_componentUniform->data));
break;
case GL_DOUBLE_VEC3:
glUniform3dv(_shaderUniform->location, _componentUniform->size,
static_cast<GLdouble*>(_componentUniform->data));
break;
case GL_DOUBLE_VEC4:
glUniform4dv(_shaderUniform->location, _componentUniform->size,
static_cast<GLdouble*>(_componentUniform->data));
break;
case GL_BOOL:
case GL_INT:
glUniform1i(_shaderUniform->location,
*static_cast<GLint*>(_componentUniform->data));
break;
case GL_BOOL_VEC2:
case GL_INT_VEC2:
glUniform2iv(_shaderUniform->location, _componentUniform->size,
static_cast<GLint*>(_componentUniform->data));
break;
case GL_BOOL_VEC3:
case GL_INT_VEC3:
glUniform3iv(_shaderUniform->location, _componentUniform->size,
static_cast<GLint*>(_componentUniform->data));
break;
case GL_BOOL_VEC4:
case GL_INT_VEC4:
glUniform4iv(_shaderUniform->location, _componentUniform->size,
static_cast<GLint*>(_componentUniform->data));
break;
case GL_UNSIGNED_INT:
glUniform1ui(_shaderUniform->location,
*static_cast<GLuint*>(_componentUniform->data));
break;
case GL_UNSIGNED_INT_VEC2:
glUniform2uiv(_shaderUniform->location, _componentUniform->size,
static_cast<GLuint*>(_componentUniform->data));
break;
case GL_UNSIGNED_INT_VEC3:
glUniform3uiv(_shaderUniform->location, _componentUniform->size,
static_cast<GLuint*>(_componentUniform->data));
break;
case GL_UNSIGNED_INT_VEC4:
glUniform4uiv(_shaderUniform->location, _componentUniform->size,
static_cast<GLuint*>(_componentUniform->data));
break;
case GL_FLOAT_MAT2:
glUniformMatrix2fv(_shaderUniform->location, _componentUniform->size,
GL_FALSE, static_cast<GLfloat*>(_componentUniform->data));
break;
case GL_FLOAT_MAT3:
glUniformMatrix3fv(_shaderUniform->location, _componentUniform->size,
GL_FALSE, static_cast<GLfloat*>(_componentUniform->data));
break;
case GL_FLOAT_MAT4:
glUniformMatrix4fv(_shaderUniform->location, _componentUniform->size,
GL_FALSE, static_cast<GLfloat*>(_componentUniform->data));
break;
case GL_FLOAT_MAT2x3:
glUniformMatrix2x3fv(_shaderUniform->location, _componentUniform->size,
GL_FALSE, static_cast<GLfloat*>(_componentUniform->data));
break;
case GL_FLOAT_MAT2x4:
glUniformMatrix2x4fv(_shaderUniform->location, _componentUniform->size,
GL_FALSE,
static_cast<GLfloat*>(_componentUniform->data));
break;
case GL_FLOAT_MAT3x2:
glUniformMatrix3x2fv(_shaderUniform->location, _componentUniform->size,
GL_FALSE,
static_cast<GLfloat*>(_componentUniform->data));
break;
case GL_FLOAT_MAT3x4:
glUniformMatrix3x4fv(_shaderUniform->location, _componentUniform->size,
GL_FALSE, static_cast<GLfloat*>(_componentUniform->data));
break;
case GL_FLOAT_MAT4x2:
glUniformMatrix4x2fv(_shaderUniform->location, _componentUniform->size,
GL_FALSE, static_cast<GLfloat*>(_componentUniform->data));
break;
case GL_FLOAT_MAT4x3:
glUniformMatrix3x4fv(_shaderUniform->location, _componentUniform->size,
GL_FALSE, static_cast<GLfloat*>(_componentUniform->data));
break;
case GL_DOUBLE_MAT2:
glUniformMatrix2dv(_shaderUniform->location, _componentUniform->size,
GL_FALSE, static_cast<GLdouble*>(_componentUniform->data));
break;
case GL_DOUBLE_MAT3:
glUniformMatrix3dv(_shaderUniform->location, _componentUniform->size,
GL_FALSE, static_cast<GLdouble*>(_componentUniform->data));
break;
case GL_DOUBLE_MAT4:
glUniformMatrix4dv(_shaderUniform->location, _componentUniform->size,
GL_FALSE, static_cast<GLdouble*>(_componentUniform->data));
break;
case GL_DOUBLE_MAT2x3:
glUniformMatrix2x3dv(_shaderUniform->location, _componentUniform->size,
GL_FALSE, static_cast<GLdouble*>(_componentUniform->data));
break;
case GL_DOUBLE_MAT2x4:
glUniformMatrix2x4dv(_shaderUniform->location, _componentUniform->size,
GL_FALSE, static_cast<GLdouble*>(_componentUniform->data));
break;
case GL_DOUBLE_MAT3x2:
glUniformMatrix3x2dv(_shaderUniform->location, _componentUniform->size,
GL_FALSE, static_cast<GLdouble*>(_componentUniform->data));
break;
case GL_DOUBLE_MAT3x4:
glUniformMatrix3x4dv(_shaderUniform->location, _componentUniform->size,
GL_FALSE, static_cast<GLdouble*>(_componentUniform->data));
break;
case GL_DOUBLE_MAT4x2:
glUniformMatrix4x2dv(_shaderUniform->location, _componentUniform->size,
GL_FALSE, static_cast<GLdouble*>(_componentUniform->data));
break;
case GL_DOUBLE_MAT4x3:
glUniformMatrix4x3dv(_shaderUniform->location, _componentUniform->size,
GL_FALSE, static_cast<GLdouble*>(_componentUniform->data));
break;
// Note(dlazarek): Currently, we handle texture-bindings outside of
// Uniform-bindigs for sorting and performance-reasons.
case GL_SAMPLER_1D:
case GL_SAMPLER_2D:
case GL_SAMPLER_3D:
case GL_SAMPLER_CUBE:
case GL_SAMPLER_1D_SHADOW:
case GL_SAMPLER_2D_SHADOW:
case GL_SAMPLER_CUBE_SHADOW:
case GL_SAMPLER_1D_ARRAY:
case GL_SAMPLER_2D_ARRAY:
case GL_SAMPLER_1D_ARRAY_SHADOW:
case GL_SAMPLER_2D_ARRAY_SHADOW:
case GL_SAMPLER_2D_MULTISAMPLE:
case GL_SAMPLER_2D_MULTISAMPLE_ARRAY:
case GL_SAMPLER_BUFFER:
case GL_SAMPLER_2D_RECT:
case GL_SAMPLER_2D_RECT_SHADOW:
case GL_INT_SAMPLER_1D:
case GL_INT_SAMPLER_2D:
case GL_INT_SAMPLER_3D:
case GL_INT_SAMPLER_CUBE:
case GL_INT_SAMPLER_1D_ARRAY:
case GL_INT_SAMPLER_2D_ARRAY:
case GL_INT_SAMPLER_2D_MULTISAMPLE:
case GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:
case GL_INT_SAMPLER_BUFFER:
case GL_INT_SAMPLER_2D_RECT:
case GL_UNSIGNED_INT_SAMPLER_1D:
case GL_UNSIGNED_INT_SAMPLER_2D:
case GL_UNSIGNED_INT_SAMPLER_3D:
case GL_UNSIGNED_INT_SAMPLER_CUBE:
case GL_UNSIGNED_INT_SAMPLER_1D_ARRAY:
case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:
case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE:
case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:
case GL_UNSIGNED_INT_SAMPLER_BUFFER:
case GL_UNSIGNED_INT_SAMPLER_2D_RECT:
//glActiveTexture(GL_TEXTURE0 + _componentUniform->texUnit);
//glProgramUniform1i(_shaderID, _shaderUniform->location, _componentUniform->texUnit);
kore::Log::getInstance()->write("[ERROR] sampler type was adressed"
"as uniform");
break;
/*
break;
case GL_IMAGE_1D:
break;
case GL_IMAGE_2D:
break;
case GL_IMAGE_3D:
break;
case GL_IMAGE_2D_RECT:
break;
case GL_IMAGE_CUBE:
break;
case GL_IMAGE_BUFFER:
break;
case GL_IMAGE_1D_ARRAY:
break;
case GL_IMAGE_2D_ARRAY:
break;
case GL_IMAGE_2D_MULTISAMPLE:
break;
case GL_IMAGE_2D_MULTISAMPLE_ARRAY:
break;
case GL_INT_IMAGE_1D:
break;
case GL_INT_IMAGE_2D:
break;
case GL_INT_IMAGE_3D:
break;
case GL_INT_IMAGE_2D_RECT:
break;
case GL_INT_IMAGE_CUBE:
break;
case GL_INT_IMAGE_BUFFER:
break;
case GL_INT_IMAGE_1D_ARRAY:
break;
case GL_INT_IMAGE_2D_ARRAY:
break;
case GL_INT_IMAGE_2D_MULTISAMPLE:
break;
case GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY:
break;
case GL_UNSIGNED_INT_IMAGE_1D:
break;
case GL_UNSIGNED_INT_IMAGE_2D:
break;
case GL_UNSIGNED_INT_IMAGE_3D:
break;
case GL_UNSIGNED_INT_IMAGE_2D_RECT:
break;
case GL_UNSIGNED_INT_IMAGE_CUBE:
break;
case GL_UNSIGNED_INT_IMAGE_BUFFER:
break;
case GL_UNSIGNED_INT_IMAGE_1D_ARRAY:
break;
case GL_UNSIGNED_INT_IMAGE_2D_ARRAY:
break;
case GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE:
break;
case GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY:
break; */
default:
kore::Log::getInstance()->write("[ERROR] Unknown uniform binding\n");
break;
}
GLerror::gl_ErrorCheckFinish("BindUniformOperation: " +
_shaderUniform->name);
}
int main(int argc, char *argv[])
{
if(!glfwInit()) {
std::cerr << "Failed to init GLFW" << std::endl;
return 1;
}
atexit(glfwTerminate);
glfwSetErrorCallback(error_callback);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
window = glfwCreateWindow(w, h, "Mandelbrot", NULL, NULL);
if(!window) {
std::cerr << "Failed to create window" << std::endl;
return 1;
}
glfwSetKeyCallback(window, key_callback);
glfwSetCursorPosCallback(window, cursor_callback);
glfwSetMouseButtonCallback(window, mouse_button_callback);
glfwSetScrollCallback(window, scroll_callback);
glfwSetInputMode(window, GLFW_CURSOR_NORMAL, GLFW_STICKY_KEYS);
glfwMakeContextCurrent(window);
glewExperimental = GL_TRUE;
glewInit();
std::cout << "Renderer: " << glGetString(GL_RENDERER) << std::endl;
std::cout << "OpenGL Version: " << glGetString(GL_VERSION) << std::endl;
GLuint prog;
compile_shader(prog);
last_mtime = get_mtime("shader.glsl");
float points[] = {
-1.0f, 1.0f, 0.0f,
-1.0f, -1.0f, 0.0f,
1.0f, -1.0f, 0.0f,
-1.0f, 1.0f, 0.0f,
1.0f, -1.0f, 0.0f,
1.0f, 1.0f, 0.0f,
};
GLuint vbo = 0;
glGenBuffers (1, &vbo);
glBindBuffer (GL_ARRAY_BUFFER, vbo);
glBufferData (GL_ARRAY_BUFFER, 2 * 9 * sizeof (float), points, GL_STATIC_DRAW);
GLuint vao = 0;
glGenVertexArrays (1, &vao);
glBindVertexArray (vao);
glEnableVertexAttribArray (0);
glBindBuffer (GL_ARRAY_BUFFER, vbo);
glVertexAttribPointer (0, 3, GL_FLOAT, GL_FALSE, 0, NULL);
glUseProgram (prog);
last_time = glfwGetTime();
glBindVertexArray (vao);
while(!glfwWindowShouldClose(window)) {
time_t new_time = get_mtime("shader.glsl");
if(new_time != last_mtime) {
glDeleteProgram(prog);
compile_shader(prog);
glUseProgram(prog);
last_mtime = new_time;
std::cout << "Reloaded shader: " << last_mtime << std::endl;
}
glfwGetWindowSize(window, &w, &h);
glUniform2d(glGetUniformLocation(prog, "screen_size"), (double)w, (double)h);
glUniform1d(glGetUniformLocation(prog, "screen_ratio"), (double)w / (double)h);
glUniform2d(glGetUniformLocation(prog, "center"), cx, cy);
glUniform1d(glGetUniformLocation(prog, "zoom"), zoom);
glUniform1i(glGetUniformLocation(prog, "itr"), itr);
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glDrawArrays (GL_TRIANGLES, 0, 6);
glfwSwapBuffers(window);
glfwPollEvents();
ticks++;
current_time = glfwGetTime();
if(current_time - last_time > 1.0) {
fps = ticks;
update_window_title();
last_time = glfwGetTime();
ticks = 0;
}
}
glfwDestroyWindow(window);
}
void ShaderProgram::setUniformData<GLdouble>(
Uniform &uniform,
const GLdouble &data
) {
glUniform1d(uniform, data);
}
