void draw_dashed_line(renderer::Command_queue& queue,
glm::vec2 p1, glm::vec2 p2, float dash_len, Rgba color) {
auto cmd = create_command()
.require_not(Gl_option::depth_test)
.require_not(Gl_option::depth_write)
.object(*unit_line)
.shader(*dashed_line_shader);
cmd.uniforms().emplace("p1", p1);
cmd.uniforms().emplace("p2", p2);
cmd.uniforms().emplace("dash_len", 1.f/dash_len);
cmd.uniforms().emplace("color", color);
queue.push_back(cmd);
}
const std::vector< GLSLProgram::UniformInformations > GLSLProgram::getActiveUniforms() const
{
if ( isInUse() )
{
// number of active uniforms
GLint numUniforms;
glGetProgramiv( getProgramObject(), GL_ACTIVE_UNIFORMS, &numUniforms );
GLint maxLength;
glGetProgramiv( getProgramObject(), GL_ACTIVE_UNIFORM_MAX_LENGTH, &maxLength );
std::vector< UniformInformations > uniforms(numUniforms, UniformInformations(maxLength) );
// for each uniform, do
for( GLint index = 0; index< numUniforms; ++index )
{
UniformInformations& uniform = uniforms[index];
glGetActiveUniform( getProgramObject(), index,
uniform.name.size(), 0,
&uniform.size, &uniform.type, &uniform.name[0] );
}
return uniforms;
}
else
{
std::vector< UniformInformations > uniforms;
return uniforms;
}
}
void
gl::VariableSet::enumerate(ProgramId program)
{
vars_.clear();
auto inserter = [this](info_t info) -> void {
auto const result = vars_.insert(
::vox::gl::VariableSet::info_container_t::value_type(info.name, info)
);
if (result.second == false) {
assert(0 && "TODO throw");
}
};
info_getter<gl::traits::attribute> attributes(program);
for (unsigned i = 0; i < attributes.count; ++i) {
inserter(attributes.get(i));
}
info_getter<gl::traits::uniform> uniforms(program);
for (unsigned i = 0; i < uniforms.count; ++i) {
inserter(uniforms.get(i));
}
}
void Material::done(const QList<string> & attributes) {
// TODO(bmonkey): deprecated, materials defined in xml
shaderProgram->init(attributes);
uniforms();
samplerUniforms();
glError;
}
void ShaderLibrary::loadAllShaders()
{
s_shaders.insert(NoShader, 0);
QVariantMap defaultParameters;
defaultParameters.insert("Shininess", QVariant(0.5));
defaultParameters.insert("Highlights", QVariant(0.5));
setUniformVariables(NoShader, defaultParameters);
QDir dir(Preferences::ShaderDirectory());
if (!dir.exists() || !dir.isReadable()) {
QLOG_WARN() << "Could not access shader directory: " + dir.path();
return;
}
QDir::Filters filters(QDir::Files | QDir::Readable);
QStringList contents(dir.entryList(filters));
unsigned program;
QStringList::iterator iter;
for (iter = contents.begin(); iter != contents.end(); ++iter) {
QFileInfo vertex(dir, *iter);
if (vertex.suffix().contains("vert", Qt::CaseInsensitive)) {
QFileInfo fragment(dir, vertex.completeBaseName() + ".frag");
if (fragment.exists()) {
QString name(fragment.completeBaseName());
name = name.replace("_", " ");
program = createProgram(vertex.filePath(), fragment.filePath());
if (program > 0) {
QLOG_DEBUG() << "Shader compilation successful:" << name;
s_shaders.insert(name, program);
QVariantMap uniforms(parseUniformVariables(vertex.filePath()));
uniforms.unite(parseUniformVariables(fragment.filePath()));
setUniformVariables(name, uniforms);
}
}
}
}
}
void Material::update_uniforms()
{
#if !defined(KINSKI_GLES)
if(!m_uniform_buffer){ m_uniform_buffer = gl::Buffer(GL_UNIFORM_BUFFER, GL_DYNAMIC_DRAW); }
struct material_struct_std140
{
vec4 diffuse;
vec4 ambient;
vec4 specular;
vec4 emission;
vec4 point_vals;
float shinyness;
uint32_t pad[3];
};
if(m_dirty_uniform_buffer)
{
material_struct_std140 m;
m.diffuse = m_diffuse;
m.ambient = m_ambient;
m.specular = m_specular;
m.emission = m_emission;
m.point_vals[0] = m_point_size;
m.point_vals[1] = m_point_attenuation.constant;
m.point_vals[2] = m_point_attenuation.linear;
m.point_vals[3] = m_point_attenuation.quadratic;
m.shinyness = m_shinyness;
m_uniform_buffer.set_data(&m, sizeof(m));
m_dirty_uniform_buffer = false;
}
glBindBufferBase(GL_UNIFORM_BUFFER, 0, m_uniform_buffer.id());
#else
if(m_dirty_uniform_buffer)
{
m_uniforms["u_material.diffuse"] = m_diffuse;
m_uniforms["u_material.ambient"] = m_ambient;
m_uniforms["u_material.specular"] = m_specular;
m_uniforms["u_material.emmission"] = m_emission;
m_uniforms["u_material.shinyness"] = m_shinyness;
m_uniforms["u_material.point_vals"] = vec4(m_point_size,
m_point_attenuation.constant,
m_point_attenuation.linear,
m_point_attenuation.quadratic);
m_dirty_uniform_buffer = false;
}
#endif
// if(m_dirty_uniform_buffer)
{
// set all other uniform values
for (auto it = uniforms().begin(); it != uniforms().end(); ++it)
{
boost::apply_visitor(InsertUniformVisitor(shader(), it->first), it->second);
KINSKI_CHECK_GL_ERRORS();
}
}
}
inline auto zeros(dtype_t d, std::vector<int> const& dims) {
return uniforms(d, dims, 0.);
}
