// Glew include
#include <GL/glew.h>
// TnzCore includes
#include "tstream.h"
#include "tmsgcore.h"
// Qt includes
#include <QGLShaderProgram>
#include <QGLShader>
#include <QDir>
#include "stdfx/shaderinterface.h"
//=========================================================
PERSIST_IDENTIFIER(ShaderInterface, "ShaderInterface")
PERSIST_IDENTIFIER(ShaderInterface::ParameterConcept, "ShaderInterface::ParameterConcept")
PERSIST_IDENTIFIER(ShaderInterface::Parameter, "ShaderInterface::Parameter")
PERSIST_IDENTIFIER(ShaderInterface::ShaderData, "ShaderInterface::ShaderData")
//**********************************************************************
// Local Namespace stuff
//**********************************************************************
namespace
{
// Filescope declarations
typedef std::pair<QGLShaderProgram *, QDateTime> CompiledShader;
struct CaselessCompare {
const QString &m_str;
CaselessCompare(const QString &str) : m_str(str) {}
bool operator()(const QString &str) const
{
return (m_str.compare(str, Qt::CaseInsensitive) == 0);
}
};
// Filescope variables
const static QString l_typeNames[ShaderInterface::TYPESCOUNT] = {
"", "bool", "float", "vec2", "vec3", "vec4", "int", "ivec2", "ivec3", "ivec4", "rgba", "rgb"};
const static QString l_conceptNames[ShaderInterface::CONCEPTSCOUNT] = {
"none", "percent", "length", "angle", "point", "radius_ui", "width_ui",
"angle_ui", "point_ui", "xy_ui", "vector_ui", "polar_ui", "size_ui", "quad_ui",
"rect_ui"};
const static QString l_hwtNames[ShaderInterface::HWTCOUNT] = {
"none", "any", "isotropic"};
enum Names { MAIN_PROGRAM,
INPUT_PORTS,
INPUT_PORT,
PORTS_PROGRAM,
PARAMETERS,
PARAMETER,
NAME,
PROGRAM_FILE,
CONCEPT,
DEFAULT_,
RANGE,
HANDLED_WORLD_TRANSFORMS,
BBOX_PROGRAM,
NAMESCOUNT };
const static std::string l_names[NAMESCOUNT] = {
"MainProgram", "InputPorts", "InputPort", "PortsProgram", "Parameters", "Parameter",
"Name", "ProgramFile", "Concept", "Default", "Range", "HandledWorldTransforms",
"BBoxProgram"};
// Filescope functions
inline bool loadShader(QGLShader::ShaderType type, const TFilePath &fp, CompiledShader &cs)
{
QGLShader *shader = new QGLShader(type, cs.first);
const QString &qfp = QString::fromStdWString(fp.getWideString());
QFileInfo shaderFileInfo(qfp);
cs.second = shaderFileInfo.lastModified();
return shader->compileSourceFile(qfp) &&
cs.first->addShader(shader);
}
void dumpError(TIStream &is, const std::wstring &err = std::wstring())
{
DVGui::info(
"Error reading " + QString::fromStdWString(is.getFilePath().getLevelNameW()) +
" (line " + QString::number(is.getLine()) + ")" +
(err.empty() ? QString() : QString::fromStdWString(L": " + err)));
}
void skipTag(TIStream &is, const std::string &tagName)
{
DVGui::info(
"Error reading " + QString::fromStdWString(is.getFilePath().getLevelNameW()) +
" (line " + QString::number(is.getLine()) +
"): Unknown tag '<" + QString::fromStdString(tagName) + ">'");
is.skipCurrentTag();
}
} // namespace
//**********************************************************************
// ShaderInterface implementation
//**********************************************************************
ShaderInterface::ShaderInterface()
: m_hwt(ANY)
{
}
//---------------------------------------------------------
void ShaderInterface::clear()
{
m_mainShader = m_portsShader = ShaderData();
m_parameters.clear();
}
//---------------------------------------------------------
bool ShaderInterface::isValid() const
{
return m_mainShader.isValid();
}
//---------------------------------------------------------
const std::vector<ShaderInterface::Parameter> &
ShaderInterface::parameters() const
{
return m_parameters;
}
//---------------------------------------------------------
const std::vector<QString> &ShaderInterface::inputPorts() const
{
return m_ports;
}
//---------------------------------------------------------
const ShaderInterface::ShaderData &ShaderInterface::mainShader() const
{
return m_mainShader;
}
//---------------------------------------------------------
const ShaderInterface::ShaderData &ShaderInterface::inputPortsShader() const
{
return m_portsShader;
}
//---------------------------------------------------------
const ShaderInterface::ShaderData &ShaderInterface::bboxShader() const
{
return m_bboxShader;
}
//---------------------------------------------------------
ShaderInterface::HandledWorldTransformsType ShaderInterface::hwtType() const
{
return m_hwt;
}
//---------------------------------------------------------
std::pair<QGLShaderProgram *, QDateTime>
ShaderInterface::makeProgram(const ShaderData &sd,
int varyingsCount, const GLchar **varyingNames) const
{
CompiledShader result;
if (!isValid())
return result;
result.first = new QGLShaderProgram;
::loadShader(sd.m_type, sd.m_path, result);
if (varyingsCount > 0)
glTransformFeedbackVaryings(result.first->programId(), varyingsCount, varyingNames, GL_INTERLEAVED_ATTRIBS);
// NOTE: Since we'll be drawing a single vertex, GL_INTERLEAVED_ATTRIBS is less restrictive than GL_SEPARATE_ATTRIBS.
result.first->link();
return result;
}
//---------------------------------------------------------
void ShaderInterface::saveData(TOStream &os)
{
struct locals {
inline static TFilePath getRelativePath(const TFilePath &file, const TFilePath &relTo)
{
QDir relToDir(QString::fromStdWString(relTo.getParentDir().getWideString()));
QString relFileStr(relToDir.relativeFilePath(QString::fromStdWString(file.getWideString())));
return TFilePath(relFileStr.toStdWString());
}
};
assert(isValid());
if (isValid()) {
os.openChild(l_names[MAIN_PROGRAM]);
os << m_mainShader;
os.closeChild();
os.openChild(l_names[INPUT_PORTS]);
{
int i, iCount = int(m_ports.size());
for (i = 0; i != iCount; ++i) {
os.openChild(l_names[INPUT_PORT]);
os << m_ports[i];
os.closeChild();
}
if (m_portsShader.isValid()) {
os.openChild(l_names[PORTS_PROGRAM]);
os << m_portsShader;
os.closeChild();
}
}
os.closeChild();
if (m_bboxShader.isValid()) {
os.openChild(l_names[BBOX_PROGRAM]);
os << m_bboxShader;
os.closeChild();
}
if (m_hwt != ANY) {
os.openChild(l_names[HANDLED_WORLD_TRANSFORMS]);
os << l_names[m_hwt];
os.closeChild();
}
os.openChild(l_names[PARAMETERS]);
{
int p, pCount = int(m_parameters.size());
for (p = 0; p != pCount; ++p) {
os.openChild(l_names[PARAMETER]);
os << m_parameters[p];
os.closeChild();
}
}
os.closeChild();
}
}
//---------------------------------------------------------
void ShaderInterface::loadData(TIStream &is)
{
struct locals {
inline static TFilePath getAbsolutePath(const TFilePath &file, const TFilePath &relTo)
{
QDir relToDir(QString::fromStdWString(relTo.getParentDir().getWideString()));
QString absFileStr(relToDir.absoluteFilePath(QString::fromStdWString(file.getWideString())));
return TFilePath(absFileStr.toStdWString());
}
static bool nameMatch(const QString &name, const Parameter ¶m)
{
return (name == param.m_name);
}
};
std::string tagName;
try {
while (is.openChild(tagName)) {
if (tagName == l_names[MAIN_PROGRAM]) {
is >> m_mainShader;
m_mainShader.m_type = QGLShader::Fragment;
is.closeChild();
} else if (tagName == l_names[INPUT_PORTS]) {
while (is.openChild(tagName)) {
if (tagName == l_names[INPUT_PORT]) {
QString portName;
is >> portName;
m_ports.push_back(portName);
is.closeChild();
} else if (tagName == l_names[PORTS_PROGRAM]) {
is >> m_portsShader;
m_portsShader.m_type = QGLShader::Vertex;
is.closeChild();
} else
::skipTag(is, tagName);
}
is.closeChild();
} else if (tagName == l_names[BBOX_PROGRAM]) {
is >> m_bboxShader;
m_bboxShader.m_type = QGLShader::Vertex;
is.closeChild();
} else if (tagName == l_names[HANDLED_WORLD_TRANSFORMS]) {
QString hwtName;
is >> hwtName;
m_hwt = HandledWorldTransformsType(std::find_if(
l_hwtNames, l_hwtNames + HWTCOUNT, ::CaselessCompare(hwtName)) -
l_hwtNames);
if (m_hwt == HWTCOUNT) {
m_hwt = HWT_UNKNOWN;
::dumpError(is, L"Unrecognized HandledWorldTransforms type '" + hwtName.toStdWString() + L"'");
}
is.closeChild();
} else if (tagName == l_names[PARAMETERS]) {
while (is.openChild(tagName)) {
if (tagName == l_names[PARAMETER]) {
Parameter param;
is >> param;
m_parameters.push_back(param);
is.closeChild();
} else
::skipTag(is, tagName);
}
is.closeChild();
} else if (tagName == l_names[CONCEPT]) {
ParameterConcept concept;
is >> concept;
m_parConcepts.push_back(concept);
is.closeChild();
} else
::skipTag(is, tagName);
};
} catch (const TException &e) {
::dumpError(is, e.getMessage());
clear();
} catch (...) {
::dumpError(is);
clear();
}
}
//**********************************************************************
// ShaderInterface::ShaderData implementation
//**********************************************************************
void ShaderInterface::ShaderData::saveData(TOStream &os)
{
struct locals {
inline static TFilePath getRelativePath(const TFilePath &file, const TFilePath &relTo)
{
QDir relToDir(QString::fromStdWString(relTo.getParentDir().getWideString()));
QString relFileStr(relToDir.relativeFilePath(QString::fromStdWString(file.getWideString())));
return TFilePath(relFileStr.toStdWString());
}
};
os.openChild(l_names[NAME]);
os << m_name;
os.closeChild();
os.openChild(l_names[PROGRAM_FILE]);
os << locals::getRelativePath(m_path, os.getFilePath());
os.closeChild();
}
//---------------------------------------------------------
void ShaderInterface::ShaderData::loadData(TIStream &is)
{
struct locals {
inline static TFilePath getAbsolutePath(const TFilePath &file, const TFilePath &relTo)
{
QDir relToDir(QString::fromStdWString(relTo.getParentDir().getWideString()));
QString absFileStr(relToDir.absoluteFilePath(QString::fromStdWString(file.getWideString())));
return TFilePath(absFileStr.toStdWString());
}
};
std::string tagName;
while (is.openChild(tagName)) {
if (tagName == l_names[NAME])
is >> m_name, is.closeChild();
else if (tagName == l_names[PROGRAM_FILE]) {
is >> m_path;
m_path = locals::getAbsolutePath(m_path, is.getFilePath());
is.closeChild();
} else
::skipTag(is, tagName);
}
}
//**********************************************************************
// ShaderInterface::ParameterConcept implementation
//**********************************************************************
void ShaderInterface::ParameterConcept::saveData(TOStream &os)
{
os << l_conceptNames[m_type];
if (!m_label.isEmpty()) {
os.openChild(l_names[NAME]);
os << m_label;
os.closeChild();
}
int n, nCount = int(m_parameterNames.size());
for (n = 0; n != nCount; ++n) {
os.openChild(l_names[PARAMETER]);
os << m_parameterNames[n];
os.closeChild();
}
}
//---------------------------------------------------------
void ShaderInterface::ParameterConcept::loadData(TIStream &is)
{
// Read the concept type
QString conceptName;
is >> conceptName;
m_type = ParameterConceptType(std::find_if(
l_conceptNames, l_conceptNames + CONCEPTSCOUNT, ::CaselessCompare(conceptName)) -
l_conceptNames);
if (m_type == CONCEPTSCOUNT) {
m_type = CONCEPT_NONE;
::dumpError(is, L"Unrecognized concept type '" + conceptName.toStdWString() + L"'");
}
// Read any associated parameter names
std::string tagName;
while (is.openChild(tagName)) {
if (tagName == l_names[PARAMETER]) {
QString name;
is >> name;
m_parameterNames.push_back(name);
is.closeChild();
} else if (tagName == l_names[NAME])
is >> m_label, is.closeChild();
else
::skipTag(is, tagName);
}
}
//**********************************************************************
// ShaderInterface::Parameter implementation
//**********************************************************************
void ShaderInterface::Parameter::saveData(TOStream &os)
{
os << l_typeNames[m_type] << m_name;
os.openChild(l_names[CONCEPT]);
os << m_concept;
os.closeChild();
os.openChild(l_names[DEFAULT_]);
switch (m_type) {
case BOOL:
os << (int)m_default.m_bool;
CASE FLOAT : os << (double)m_default.m_float;
CASE VEC2 : os << (double)m_default.m_vec2[0] << (double)m_default.m_vec2[1];
CASE VEC3 : os << (double)m_default.m_vec3[0] << (double)m_default.m_vec3[1]
<< (double)m_default.m_vec3[2];
CASE VEC4 : os << (double)m_default.m_vec4[0] << (double)m_default.m_vec4[1]
<< (double)m_default.m_vec4[2]
<< (double)m_default.m_vec4[3];
CASE INT : os << m_default.m_int;
CASE IVEC2 : os << m_default.m_ivec2[0] << m_default.m_ivec2[1];
CASE IVEC3 : os << m_default.m_ivec3[0] << m_default.m_ivec3[1]
<< m_default.m_ivec3[2];
CASE IVEC4 : os << m_default.m_ivec4[0] << m_default.m_ivec4[1]
<< m_default.m_ivec4[2]
<< m_default.m_ivec4[3];
CASE RGBA : os << (int)m_default.m_rgba[0] << (int)m_default.m_rgba[1]
<< (int)m_default.m_rgba[2]
<< (int)m_default.m_rgba[3];
CASE RGB : os << (int)m_default.m_rgb[0] << (int)m_default.m_rgb[1]
<< (int)m_default.m_rgb[2];
DEFAULT:;
};
os.closeChild();
os.openChild(l_names[RANGE]);
switch (m_type) {
case FLOAT:
os << (double)m_range[0].m_float << (double)m_range[1].m_float;
CASE VEC2 : os << (double)m_range[0].m_vec2[0] << (double)m_range[1].m_vec2[0]
<< (double)m_range[0].m_vec2[1]
<< (double)m_range[1].m_vec2[1];
CASE VEC3 : os << (double)m_range[0].m_vec3[0] << (double)m_range[1].m_vec3[0]
<< (double)m_range[0].m_vec3[1]
<< (double)m_range[1].m_vec3[1]
<< (double)m_range[0].m_vec3[2]
<< (double)m_range[1].m_vec3[2];
CASE VEC4 : os << (double)m_range[0].m_vec4[0] << (double)m_range[1].m_vec4[0]
<< (double)m_range[0].m_vec4[1]
<< (double)m_range[1].m_vec4[1]
<< (double)m_range[0].m_vec4[2]
<< (double)m_range[1].m_vec4[2]
<< (double)m_range[0].m_vec4[3]
<< (double)m_range[1].m_vec4[3];
CASE INT : os << m_range[0].m_int << m_range[1].m_int;
CASE IVEC2 : os << m_range[0].m_ivec2[0] << m_range[1].m_ivec2[0]
<< m_range[0].m_ivec2[1]
<< m_range[1].m_ivec2[1];
CASE IVEC3 : os << m_range[0].m_ivec3[0] << m_range[1].m_ivec3[0]
<< m_range[0].m_ivec3[1]
<< m_range[1].m_ivec3[1]
<< m_range[0].m_ivec3[2]
<< m_range[1].m_ivec3[2];
CASE IVEC4 : os << m_range[0].m_ivec4[0] << m_range[1].m_ivec4[0]
<< m_range[0].m_ivec4[1]
<< m_range[1].m_ivec4[1]
<< m_range[0].m_ivec4[2]
<< m_range[1].m_ivec4[2]
<< m_range[0].m_ivec4[3]
<< m_range[1].m_ivec4[3];
DEFAULT:;
};
os.closeChild();
}
//---------------------------------------------------------
void ShaderInterface::Parameter::loadData(TIStream &is)
{
// Load type and name
QString typeName;
is >> typeName >> m_name;
m_type = ShaderInterface::ParameterType(std::find_if(
l_typeNames, l_typeNames + TYPESCOUNT, ::CaselessCompare(typeName)) -
l_typeNames);
if (m_type == TYPESCOUNT)
throw TException(L"Unrecognized parameter type '" + typeName.toStdWString() + L"'");
// Load range
std::string tagName;
// Initialize default values
m_concept = ParameterConcept();
switch (m_type) {
case BOOL:
m_default.m_bool = false;
CASE FLOAT:
{
m_default.m_float = 0.0;
m_range[0].m_float = -(std::numeric_limits<GLfloat>::max)();
m_range[1].m_float = (std::numeric_limits<GLfloat>::max)();
}
CASE VEC2:
{
m_default.m_vec2[0] = m_default.m_vec2[1] = 0.0;
m_range[0].m_vec2[0] = m_range[0].m_vec2[1] = -(std::numeric_limits<GLfloat>::max)();
m_range[1].m_vec2[0] = m_range[1].m_vec2[1] = (std::numeric_limits<GLfloat>::max)();
}
CASE VEC3:
{
m_default.m_vec3[0] = m_default.m_vec3[1] = m_default.m_vec3[1] = 0.0;
m_range[0].m_vec3[0] = m_range[0].m_vec3[1] = m_range[0].m_vec3[2] = -(std::numeric_limits<GLfloat>::max)();
m_range[1].m_vec3[0] = m_range[1].m_vec3[1] = m_range[1].m_vec3[2] = (std::numeric_limits<GLfloat>::max)();
}
CASE VEC4:
{
m_default.m_vec4[0] = m_default.m_vec4[1] =
m_default.m_vec4[1] = m_default.m_vec4[1] = 0.0;
m_range[0].m_vec4[0] = m_range[0].m_vec4[1] =
m_range[0].m_vec4[2] = m_range[0].m_vec4[3] = -(std::numeric_limits<GLfloat>::max)();
m_range[1].m_vec4[0] = m_range[1].m_vec4[1] =
m_range[1].m_vec4[2] = m_range[1].m_vec4[3] = (std::numeric_limits<GLfloat>::max)();
}
CASE INT:
{
m_default.m_int = 0;
m_range[0].m_int = -(std::numeric_limits<GLint>::max)();
m_range[1].m_int = (std::numeric_limits<GLint>::max)();
}
CASE IVEC2:
{
m_default.m_ivec2[0] = m_default.m_ivec2[1] = 0;
m_range[0].m_ivec2[0] = m_range[0].m_ivec2[1] = -(std::numeric_limits<GLint>::max)();
m_range[1].m_ivec2[0] = m_range[1].m_ivec2[1] = (std::numeric_limits<GLint>::max)();
}
CASE IVEC3:
{
m_default.m_ivec3[0] = m_default.m_ivec3[1] = m_default.m_ivec3[1] = 0;
m_range[0].m_ivec3[0] = m_range[0].m_ivec3[1] = m_range[0].m_ivec3[2] = -(std::numeric_limits<GLint>::max)();
m_range[1].m_ivec3[0] = m_range[1].m_ivec3[1] = m_range[1].m_ivec3[2] = (std::numeric_limits<GLint>::max)();
}
CASE IVEC4:
{
m_default.m_ivec4[0] = m_default.m_ivec4[1] =
m_default.m_ivec4[1] = m_default.m_ivec4[1] = 0;
m_range[0].m_ivec4[0] = m_range[0].m_ivec4[1] =
m_range[0].m_ivec4[2] = m_range[0].m_ivec4[3] = -(std::numeric_limits<GLint>::max)();
m_range[1].m_ivec4[0] = m_range[1].m_ivec4[1] =
m_range[1].m_ivec4[2] = m_range[1].m_ivec4[3] = (std::numeric_limits<GLint>::max)();
}
CASE RGBA:
{
m_default.m_rgba[0] = m_default.m_rgba[1] =
m_default.m_rgba[2] = m_default.m_rgba[3] = 255;
}
CASE RGB:
{
m_default.m_rgb[0] = m_default.m_rgb[1] =
m_default.m_rgb[2] = 255;
}
DEFAULT:;
};
// Attempt loading range from file
while (is.openChild(tagName)) {
if (tagName == l_names[CONCEPT])
is >> m_concept, is.closeChild();
else if (tagName == l_names[DEFAULT_]) {
switch (m_type) {
case BOOL: {
int val;
is >> val, m_default.m_bool = val;
}
CASE FLOAT:
{
double val;
is >> val, m_default.m_float = val;
}
CASE VEC2:
{
double val;
is >> val, m_default.m_vec2[0] = val;
is >> val, m_default.m_vec2[1] = val;
}
CASE VEC3:
{
double val;
is >> val, m_default.m_vec3[0] = val;
is >> val, m_default.m_vec3[1] = val;
is >> val, m_default.m_vec3[2] = val;
}
CASE VEC4:
{
double val;
is >> val, m_default.m_vec4[0] = val;
is >> val, m_default.m_vec4[1] = val;
is >> val, m_default.m_vec4[2] = val;
is >> val, m_default.m_vec4[3] = val;
}
CASE INT : is >> m_default.m_int;
CASE IVEC2 : is >> m_default.m_ivec2[0] >> m_default.m_ivec2[1];
CASE IVEC3 : is >> m_default.m_ivec3[0] >> m_default.m_ivec3[1] >> m_default.m_ivec3[2];
CASE IVEC4 : is >> m_default.m_ivec4[0] >> m_default.m_ivec4[1] >> m_default.m_ivec4[2] >> m_default.m_ivec4[3];
CASE RGBA:
{
int val;
is >> val, m_default.m_rgba[0] = val;
is >> val, m_default.m_rgba[1] = val;
is >> val, m_default.m_rgba[2] = val;
is >> val, m_default.m_rgba[3] = val;
}
CASE RGB:
{
int val;
is >> val, m_default.m_rgb[0] = val;
is >> val, m_default.m_rgb[1] = val;
is >> val, m_default.m_rgb[2] = val;
}
DEFAULT:;
}
is.closeChild();
} else if (tagName == l_names[RANGE]) {
switch (m_type) {
case FLOAT: {
double val;
is >> val, m_range[0].m_float = val;
is >> val, m_range[1].m_float = val;
}
CASE VEC2:
{
double val;
is >> val, m_range[0].m_vec2[0] = val;
is >> val, m_range[1].m_vec2[0] = val;
is >> val, m_range[0].m_vec2[1] = val;
is >> val, m_range[1].m_vec2[1] = val;
}
CASE VEC3:
{
double val;
is >> val, m_range[0].m_vec3[0] = val;
is >> val, m_range[1].m_vec3[0] = val;
is >> val, m_range[0].m_vec3[1] = val;
is >> val, m_range[1].m_vec3[1] = val;
is >> val, m_range[0].m_vec3[2] = val;
is >> val, m_range[1].m_vec3[2] = val;
}
CASE VEC4:
{
double val;
is >> val, m_range[0].m_vec4[0] = val;
is >> val, m_range[1].m_vec4[0] = val;
is >> val, m_range[0].m_vec4[1] = val;
is >> val, m_range[1].m_vec4[1] = val;
is >> val, m_range[0].m_vec4[2] = val;
is >> val, m_range[1].m_vec4[2] = val;
is >> val, m_range[0].m_vec4[3] = val;
is >> val, m_range[1].m_vec4[3] = val;
}
CASE INT : is >> m_range[0].m_int >> m_range[1].m_int;
CASE IVEC2 : is >> m_range[0].m_ivec2[0] >> m_range[1].m_ivec2[0] >> m_range[0].m_ivec2[1] >> m_range[1].m_ivec2[1];
CASE IVEC3 : is >> m_range[0].m_ivec3[0] >> m_range[1].m_ivec3[0] >> m_range[0].m_ivec3[1] >> m_range[1].m_ivec3[1] >> m_range[0].m_ivec3[2] >> m_range[1].m_ivec3[2];
CASE IVEC4 : is >> m_range[0].m_ivec4[0] >> m_range[1].m_ivec4[0] >> m_range[0].m_ivec4[1] >> m_range[1].m_ivec4[1] >> m_range[0].m_ivec4[2] >> m_range[1].m_ivec4[2] >> m_range[0].m_ivec4[3] >> m_range[1].m_ivec4[3];
DEFAULT:;
}
is.closeChild();
} else
::skipTag(is, tagName);
}
// Post-process loaded data
if (m_concept.m_label.isEmpty())
m_concept.m_label = m_name;
}