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); }