/* TODO: error checking */
static int attachShaderObject(GLint programHandle, GLenum type, const char *src)
{
GLint shader, status;
int error;
dbgPrint(DBGLVL_COMPILERINFO,
"ATTACH SHADER: %s\n-----------------\n%s\n--------------\n",
lookupEnum(type), src);
shader = ORIG_GL(glCreateShader)(type);
error = glError();
if (error) {
return error;
}
ORIG_GL(glShaderSource)(shader, 1, (void*)&src, NULL);
error = glError();
if (error) {
return error;
}
ORIG_GL(glCompileShader)(shader);
error = glError();
if (error) {
return error;
}
ORIG_GL(glGetShaderiv)(shader, GL_COMPILE_STATUS, &status);
error = glError();
if (error) {
return error;
}
printShaderInfoLog(shader);
error = glError();
if (error) {
return error;
}
if (!status) {
dbgPrint(DBGLVL_ERROR, "DBG SHADER COMPILATION for %s failed!\n", lookupEnum(type));
return DBG_ERROR_DBG_SHADER_COMPILE_FAILED;
}
ORIG_GL(glAttachShader)(programHandle, shader);
error = glError();
if (error) {
return error;
}
ORIG_GL(glDeleteShader)(shader);
error = glError();
if (error) {
return error;
}
return DBG_NO_ERROR;
}
bool DataTableColumnType::lookupBitVector(std::string const &label, int &result) const
{
std::string localLabel = label;
if(strcmp(label.c_str(), "NONE") == 0)
{
result = 0;
return true;
}
bool foundAny = false;
localLabel += ",";
// enumList looks like "foo,bar,life,"
std::string::size_type eqPos;
while ((eqPos = localLabel.find(',')) != std::string::npos)
{
std::string::size_type endPos = localLabel.find(',');
std::string subLabel = chomp(localLabel.substr(0, eqPos));
int subResult;
if(lookupEnum(subLabel, subResult))
{
foundAny = true;
result |= subResult;
}
else
{
DEBUG_WARNING(true, ("DataTableColumnType::lookupEnumExtended found invalid enum value '%s'", subLabel.c_str()));
}
localLabel.erase(0, endPos+1);
}
return foundAny;
}
/*
* Look up a qualified Python type and return the corresponding node (or NULL
* if the type should be omitted because of a recursive definition).
*/
static typeHintNodeDef *lookupType(sipSpec *pt, char *name, int out)
{
char *sp, *ep;
classDef *scope_cd;
mappedTypeDef *scope_mtd;
typeHintDef *thd;
typeHintNodeDef *node;
/* Start searching at the global level. */
scope_cd = NULL;
scope_mtd = NULL;
sp = name;
ep = NULL;
while (*sp != '\0')
{
enumDef *ed;
/* Isolate the next part of the name. */
if ((ep = strchr(sp, '.')) != NULL)
*ep = '\0';
/* See if it's an enum. */
if ((ed = lookupEnum(pt, sp, scope_cd, scope_mtd)) != NULL)
{
/* Make sure we have used the whole name. */
if (ep == NULL)
{
node = sipMalloc(sizeof (typeHintNodeDef));
node->type = enum_node;
node->u.ed = ed;
return node;
}
/* There is some left so the whole lookup has failed. */
break;
}
/*
* If we have a mapped type scope then we must be looking for an enum,
* which we have failed to find.
*/
if (scope_mtd != NULL)
break;
if (scope_cd == NULL)
{
mappedTypeDef *mtd;
/*
* We are looking at the global level, so see if it is a mapped
* type.
*/
if ((mtd = lookupMappedType(pt, sp)) != NULL)
{
/*
* If we have used the whole name then the lookup has
* succeeded.
*/
if (ep == NULL)
{
thd = (out ? mtd->typehint_out : mtd->typehint_in);
if (thd != NULL && thd->status != being_parsed)
return copyTypeHintNode(pt, thd, out);
/*
* If we get here we have a recursively defined mapped type
* so we simply omit it.
*/
return NULL;
}
/* Otherwise this is the scope for the next part. */
scope_mtd = mtd;
}
}
if (scope_mtd == NULL)
{
classDef *cd;
/* If we get here then it must be a class. */
if ((cd = lookupClass(pt, sp, scope_cd)) == NULL)
break;
/* If we have used the whole name then the lookup has succeeded. */
if (ep == NULL)
{
thd = (out ? cd->typehint_out : cd->typehint_in);
if (thd != NULL && thd->status != being_parsed)
return copyTypeHintNode(pt, thd, out);
node = sipMalloc(sizeof (typeHintNodeDef));
node->type = class_node;
node->u.cd = cd;
return node;
}
/* Otherwise this is the scope for the next part. */
scope_cd = cd;
}
/* If we have run out of name then the lookup has failed. */
if (ep == NULL)
break;
/* Repair the name and go on to the next part. */
*ep++ = '.';
sp = ep;
}
/* Repair the name. */
if (ep != NULL)
*ep = '.';
/* Nothing was found. */
node = sipMalloc(sizeof (typeHintNodeDef));
node->type = other_node;
node->u.name = sipStrdup(name);
return node;
}
static int getActiveAttributes(ShaderProgram *shader)
{
GLint maxLength;
char *name = NULL;
int i, error;
ORIG_GL(glGetProgramiv)(shader->programHandle, GL_ACTIVE_ATTRIBUTES,
&shader->numAttributes);
ORIG_GL(glGetProgramiv)(shader->programHandle,
GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &maxLength);
error = glError();
if (error) {
shader->numAttributes = 0;
return error;
}
if (!(name = (char*)malloc(maxLength*sizeof(char)))) {
dbgPrint(DBGLVL_ERROR, "Allocation failed: attrib name\n");
shader->numAttributes = 0;
return DBG_ERROR_MEMORY_ALLOCATION_FAILED;
}
dbgPrint(DBGLVL_INFO, "ACTIVE ATTRIBS: %i\n", shader->numAttributes);
if (!(shader->attributes = (ActiveAttribute*)malloc(shader->numAttributes*
sizeof(ActiveAttribute)))) {
dbgPrint(DBGLVL_ERROR, "Allocation failed: attributes\n");
shader->numAttributes = 0;
free(name);
return DBG_ERROR_MEMORY_ALLOCATION_FAILED;
}
for (i = 0; i < shader->numAttributes; i++) {
ActiveAttribute *a = &shader->attributes[i];
ORIG_GL(glGetActiveAttrib)(shader->programHandle, i, maxLength, NULL,
&a->size, &a->type, name);
error = glError();
if (error) {
shader->numAttributes = i;
free(name);
return error;
}
if (!(a->name = strdup(name))) {
dbgPrint(DBGLVL_ERROR, "Allocation failed: attribute name\n");
shader->numAttributes = i;
free(name);
return DBG_ERROR_MEMORY_ALLOCATION_FAILED;
}
if (!strncmp(a->name, "gl_", 3)) {
a->builtin = 1;
a->location = -1;
} else {
a->builtin = 0;
a->location = ORIG_GL(glGetAttribLocation)(shader->programHandle,
a->name);
error = glError();
if (error) {
shader->numAttributes = i + 1;
free(name);
return error;
}
}
dbgPrint(DBGLVL_INFO, "SAVED ATTRIB: %s size=%i type=%s, location=%i\n",
a->name, a->size, lookupEnum(a->type), a->location);
}
free(name);
return DBG_NO_ERROR;
}
static int getActiveUniforms(ShaderProgram *shader)
{
GLint maxLength;
char *name = NULL;
int i, error, numBaseUniforms, n;
ActiveUniform *baseUniforms = NULL;
ORIG_GL(glGetProgramiv)(shader->programHandle, GL_ACTIVE_UNIFORMS,
&numBaseUniforms);
ORIG_GL(glGetProgramiv)(shader->programHandle, GL_ACTIVE_UNIFORM_MAX_LENGTH,
&maxLength);
error = glError();
if (error) {
shader->numUniforms = 0;
return error;
}
if (!(name = (char*)malloc(maxLength*sizeof(char)))) {
dbgPrint(DBGLVL_ERROR, "Allocation failed: uniform name\n");
shader->numUniforms = 0;
return DBG_ERROR_MEMORY_ALLOCATION_FAILED;
}
dbgPrint(DBGLVL_INFO, "ACTIVE UNIFORMS: %i\n", numBaseUniforms);
if (!(baseUniforms = (ActiveUniform*)malloc(numBaseUniforms*sizeof(ActiveUniform)))) {
dbgPrint(DBGLVL_ERROR, "Allocation failed: base uniforms\n");
shader->numUniforms = 0;
free(name);
return DBG_ERROR_MEMORY_ALLOCATION_FAILED;
}
shader->numUniforms = 0;
for (i = 0; i < numBaseUniforms; i++) {
ActiveUniform *u = &baseUniforms[i];
ORIG_GL(glGetActiveUniform)(shader->programHandle, i, maxLength, NULL,
&u->size, &u->type, name);
error = glError();
if (error) {
free(name);
free(baseUniforms);
shader->numUniforms = 0;
return error;
}
dbgPrint(DBGLVL_INFO, "FOUND UNIFORM: %s size=%i type=%s\n",
name, u->size, lookupEnum(u->type));
if (!strncmp(name, "gl_", 3)) {
u->builtin = 1;
} else {
if (!(u->name = strdup(name))) {
dbgPrint(DBGLVL_ERROR, "Allocation failed: uniform name\n");
free(name);
free(baseUniforms);
shader->numUniforms = 0;
return DBG_ERROR_MEMORY_ALLOCATION_FAILED;
}
u->builtin = 0;
shader->numUniforms += u->size;
}
}
free(name);
if (!(shader->uniforms = (ActiveUniform*)malloc(shader->numUniforms*sizeof(ActiveUniform)))) {
dbgPrint(DBGLVL_ERROR, "Allocation failed: uniforms\n");
shader->numUniforms = 0;
free(baseUniforms);
return DBG_ERROR_MEMORY_ALLOCATION_FAILED;
}
n = 0;
for (i = 0; i < numBaseUniforms; i++) {
ActiveUniform *bu = &baseUniforms[i];
if (!bu->builtin) {
if (bu->size == 1) {
ActiveUniform *u = &shader->uniforms[n];
u->type = bu->type;
u->size = 1;
u->builtin = 0;
u->value = NULL;
if (!(u->name = strdup(bu->name))) {
dbgPrint(DBGLVL_ERROR, "Allocation failed: uniform name\n");
free(baseUniforms);
shader->numUniforms = n;
return DBG_ERROR_MEMORY_ALLOCATION_FAILED;
}
u->location = ORIG_GL(glGetUniformLocation)(shader->programHandle,
u->name);
error = glError();
if (error) {
free(baseUniforms);
free(u->name);
shader->numUniforms = n;
return error;
}
dbgPrint(DBGLVL_INFO, "SAVE UNIFORM: %s size=%i type=%s location=%i\n",
u->name, u->size, lookupEnum(u->type), u->location);
error = getUniform(shader->programHandle, u);
if (error) {
free(u->name);
free(baseUniforms);
shader->numUniforms = n;
return error;
}
n++;
} else {
int j;
for (j = 0; j < bu->size; j++) {
ActiveUniform *u = &shader->uniforms[n];
u->type = bu->type;
u->size = 1;
u->builtin = 0;
u->value = NULL;
if (asprintf(&u->name, "%s[%i]", bu->name, j) < 0) {
dbgPrint(DBGLVL_ERROR, "Allocation failed: uniform name\n");
free(baseUniforms);
shader->numUniforms = n;
return DBG_ERROR_MEMORY_ALLOCATION_FAILED;
}
u->location = ORIG_GL(glGetUniformLocation)(shader->programHandle,
u->name);
error = glError();
if (error) {
free(baseUniforms);
free(u->name);
shader->numUniforms = n;
return error;
}
dbgPrint(DBGLVL_INFO, "SAVE UNIFORM: %s size=%i type=%s location=%i\n",
u->name, u->size, lookupEnum(u->type), u->location);
error = getUniform(shader->programHandle, u);
if (error) {
free(u->name);
free(baseUniforms);
shader->numUniforms = n;
return error;
}
n++;
}
}
}
}
free(baseUniforms);
return DBG_NO_ERROR;
}
int loadDbgShader(const char* vshader, const char *gshader, const char *fshader,
int target, int forcePointPrimitiveMode)
{
int haveGeometryShader = checkGLExtensionSupported("GL_EXT_geometry_shader4");
GLint status;
int i, error;
freeDbgShader();
g.dbgShaderHandle = ORIG_GL(glCreateProgram)();
error = glError();
if (error) {
return error;
}
dbgPrint(DBGLVL_COMPILERINFO, "SET DBG SHADER: %p, %p, %p %i\n",
vshader, gshader, fshader, target);
if (vshader) {
error = attachShaderObject(g.dbgShaderHandle, GL_VERTEX_SHADER, vshader);
if (error) {
freeDbgShader();
return error;
}
}
if (gshader && target != DBG_TARGET_VERTEX_SHADER) {
error = attachShaderObject(g.dbgShaderHandle, GL_GEOMETRY_SHADER_EXT,
gshader);
if (error) {
freeDbgShader();
return error;
}
}
if (fshader) {
error = attachShaderObject(g.dbgShaderHandle, GL_FRAGMENT_SHADER,
fshader);
if (error) {
freeDbgShader();
return error;
}
}
/* copy execution environment of previous active shader */
/* pre-link part */
if (g.storedShader.programHandle == 0) {
dbgPrint(DBGLVL_ERROR, "STORE CURRENTLY ACTIVE SHADER BEFORE SETTING DBG SHADER!\n");
freeDbgShader();
return DBG_ERROR_NO_STORED_SHADER;
}
for (i = 0; i < g.storedShader.numAttributes; i++) {
ActiveAttribute *a = &g.storedShader.attributes[i];
if (!a->builtin) {
/* glGetAttribLocation is not allowed before link
int location;
if (haveOpenGL_2_0_GLSL) {
location = ORIG_GL(glGetAttribLocation)(g.dbgShaderHandle, a->name);
if (location != -1) {
ORIG_GL(glBindAttribLocation)(g.dbgShaderHandle, a->location,
a->name);
}
} else {
location = ORIG_GL(glGetAttribLocationARB)(g.dbgShaderHandle, a->name);
if (location != -1) {
ORIG_GL(glBindAttribLocationARB)(g.dbgShaderHandle, a->location,
a->name);
}
}
*/
ORIG_GL(glBindAttribLocation)(g.dbgShaderHandle, a->location,
a->name);
error = glError();
if (error) {
freeDbgShader();
return error;
}
dbgPrint(DBGLVL_INFO, "BINDATTRIBLOCATION: %s -> %i\n", a->name, a->location);
}
}
/* if geometry shader is supported, set program parameters */
if (haveGeometryShader && gshader) {
DMARK
dbgPrint(DBGLVL_INFO, "SET PROGRAM PARAMETERS: "
"GL_GEOMETRY_VERTICES_OUT_EXT=%i "
"GL_GEOMETRY_INPUT_TYPE_EXT=%s "
"GL_GEOMETRY_OUTPUT_TYPE_EXT=%s\n",
g.storedShader.geoVerticesOut,
lookupEnum(g.storedShader.geoInputType),
lookupEnum(g.storedShader.geoOutputType));
ORIG_GL(glProgramParameteriEXT)(g.dbgShaderHandle,
GL_GEOMETRY_VERTICES_OUT_EXT,
g.storedShader.geoVerticesOut);
ORIG_GL(glProgramParameteriEXT)(g.dbgShaderHandle,
GL_GEOMETRY_INPUT_TYPE_EXT,
g.storedShader.geoInputType);
if (forcePointPrimitiveMode) {
ORIG_GL(glProgramParameteriEXT)(g.dbgShaderHandle,
GL_GEOMETRY_OUTPUT_TYPE_EXT,
GL_POINTS);
} else {
ORIG_GL(glProgramParameteriEXT)(g.dbgShaderHandle,
GL_GEOMETRY_OUTPUT_TYPE_EXT,
g.storedShader.geoOutputType);
}
error = glError();
if (error) {
freeDbgShader();
return error;
}
}
/* TODO: other state (point size, geometry shader, etc.) !!! */
/* if debug target is vertex or geometry shader, force varyings active that
* are used in transform feedback
*/
if (target == DBG_TARGET_GEOMETRY_SHADER ||
target == DBG_TARGET_VERTEX_SHADER) {
switch (getTFBVersion()) {
case TFBVersion_NV:
ORIG_GL(glActiveVaryingNV)(g.dbgShaderHandle, "dbgResult"/*TODO*/);
error = glError();
if (error) {
freeDbgShader();
return error;
}
break;
case TFBVersion_EXT:
{
const char* dbgTFBVaryings[] = {"dbgResult"};
ORIG_GL(glTransformFeedbackVaryingsEXT)(g.dbgShaderHandle, 1, dbgTFBVaryings, GL_SEPARATE_ATTRIBS_EXT);
error = glError();
if (error) {
freeDbgShader();
return error;
}
}
break;
default:
dbgPrint(DBGLVL_ERROR, "Unknown TFB version!\n");
return DBG_ERROR_INVALID_OPERATION;
}
}
/* link debug shader */
ORIG_GL(glLinkProgram)(g.dbgShaderHandle);
ORIG_GL(glGetProgramiv)(g.dbgShaderHandle, GL_LINK_STATUS, &status);
error = glError();
if (error) {
freeDbgShader();
return error;
}
printProgramInfoLog(g.dbgShaderHandle);
if (!status) {
dbgPrint(DBGLVL_ERROR, "LINKING DBG SHADER FAILED!\n");
freeDbgShader();
return DBG_ERROR_DBG_SHADER_LINK_FAILED;
}
/* if debug target is vertex or geometry shader, specify varyings that
* are used in transform feedback
*/
if (target == DBG_TARGET_GEOMETRY_SHADER ||
target == DBG_TARGET_VERTEX_SHADER) {
GLint location;
switch (getTFBVersion()) {
case TFBVersion_NV:
{
location = ORIG_GL(glGetVaryingLocationNV)(g.dbgShaderHandle, "dbgResult"/*TODO*/);
if (location < 0) {
dbgPrint(DBGLVL_ERROR, "dbgResult NOT ACTIVE VARYING\n");
freeDbgShader();
return DBG_ERROR_VARYING_INACTIVE;
}
ORIG_GL(glTransformFeedbackVaryingsNV)(g.dbgShaderHandle, 1, &location, GL_SEPARATE_ATTRIBS_NV);
error = glError();
if (error) {
freeDbgShader();
return error;
}
}
break;
case TFBVersion_EXT:
/* nothing to be done, the EXT extension requires to specify the
* transform feedback varying outputs *befor* linking the shader
*/
break;
default:
return DBG_ERROR_INVALID_OPERATION;
}
}
/* activate debug shader */
ORIG_GL(glUseProgram)(g.dbgShaderHandle);
error = glError();
if (error) {
freeDbgShader();
return error;
}
/* copy execution environment of previous active shader */
/* post-link part */
for (i = 0; i < g.storedShader.numUniforms; i++) {
ActiveUniform *u = &g.storedShader.uniforms[i];
if (!u->builtin) {
error = setUniform(g.dbgShaderHandle, u);
if (error) {
freeDbgShader();
return error;
}
}
}
/* TODO: other state (GL_EXT_bindable_uniform etc.) !!! */
return DBG_NO_ERROR;
}
bool DataTableColumnType::mangleValue(std::string &value) const
{
// if the value passed in is empty, we mangle to the default value
if (value.length() == 0)
{
if (m_defaultValue == "required" || m_defaultValue == "unique")
return false;
else
value = m_defaultValue;
}
// special validation code for packed objvars
if (m_type == DT_PackedObjVars)
{
// packed objvars are of the form:
// nameString|typeInt|valueString|nameString|typeInt|valueString|$|
// where || may be used in the string fields to represent a |
char const *s = value.c_str();
while (*s)
{
// name
if (s[0] == '$' && s[1] == '|' && s[2] == '\0')
break;
if (!consumePackedObjVarStringField(s))
return false;
// type
if (!consumePackedObjVarIntField(s))
return false;
// value
if (!consumePackedObjVarStringField(s))
return false;
}
}
// only basic type DT_Int are complex types that use value mangling other
// than default values
if (m_basicType != DT_Int || m_type == DT_Int)
return true;
// complex type which needs mangling
switch (m_type)
{
case DT_Bool:
{
if (value == "0" || value == "1")
return true;
}
break;
case DT_HashString:
{
// conversion to integer crc
int val;
if (value.length())
val = Crc::normalizeAndCalculate(value.c_str());
else
val = Crc::crcNull;
char buf[16];
sprintf(buf, "%d", val);
value = buf;
return true;
}
break;
case DT_Enum:
{
// enumeration lookup
int val = 0;
if (lookupEnum(value, val))
{
char buf[16];
sprintf(buf, "%d", val);
value = buf;
return true;
}
}
break;
case DT_BitVector:
{
// enumeration lookup
int val = 0;
if (lookupBitVector(value, val))
{
char buf[16];
sprintf(buf, "%d", val);
value = buf;
return true;
}
}
break;
default:
break;
}
return false;
}
WatchGeoDataTree::WatchGeoDataTree(int inPrimitiveType, int outPrimitiveType,
VertexBox *primitiveMap, VertexBox *vertexCount, QWidget *parent) :
WatchView(parent)
{
/* Setup GUI */
setupUi(this);
fMapping->setVisible(false);
m_dataModel = new GeoShaderDataModel(inPrimitiveType, outPrimitiveType,
primitiveMap, vertexCount, NULL, NULL, this);
m_filterProxy = new GeoShaderDataSortFilterProxyModel(this);
m_filterProxy->setSourceModel(m_dataModel);
m_filterProxy->setDynamicSortFilter(true);
connect(tbHideInactive, SIGNAL(toggled(bool)), m_filterProxy,
SLOT(setHideInactive(bool)));
connect(tbHideEmpty, SIGNAL(toggled(bool)), m_filterProxy,
SLOT(setHideEmpty(bool)));
tvGeoData->setModel(m_filterProxy);
tvGeoData->setAllColumnsShowFocus(true);
tvGeoData->setUniformRowHeights(true);
connect(tvGeoData, SIGNAL(doubleClicked(const QModelIndex &)), this,
SLOT(newSelection(const QModelIndex &)));
connect(m_dataModel, SIGNAL(dataDeleted(int)), this, SLOT(detachData(int)));
connect(m_dataModel, SIGNAL(empty()), this, SLOT(closeView()));
twGeoInfo->item(0, 0)->setText(QString(lookupEnum(inPrimitiveType)));
twGeoInfo->item(1, 0)->setText(
QString::number(m_dataModel->getNumInPrimitives()));
twGeoInfo->item(0, 2)->setText(QString(lookupEnum(outPrimitiveType)));
twGeoInfo->item(1, 2)->setText(
QString::number(m_dataModel->getNumOutPrimitives()));
if (GeoShaderDataModel::isBasicPrimitive(inPrimitiveType)) {
twGeoInfo->hideColumn(1);
} else {
twGeoInfo->item(0, 1)->setText(
lookupEnum(
GeoShaderDataModel::getBasePrimitive(inPrimitiveType)));
twGeoInfo->item(1, 1)->setText(
QString::number(m_dataModel->getNumSubInPrimitives()));
}
twGeoInfo->resizeColumnsToContents();
twGeoInfo->resizeRowsToContents();
twGeoInfo->setSelectionBehavior(QAbstractItemView::SelectRows);
// Add OpenGL view to window
QGridLayout *gridLayout;
gridLayout = new QGridLayout(fGLview);
gridLayout->setSpacing(0);
gridLayout->setMargin(0);
m_qGLscatter = new GLScatter(this);
gridLayout->addWidget(m_qGLscatter);
slPointSize->setMinimum(1);
slPointSize->setMaximum(1000);
slPointSize->setValue(300);
slPointSize->setTickInterval(50);
m_scatterPositions = NULL;
m_scatterColorsAndSizes = NULL;
m_dataSelection = DATA_CURRENT;
m_maxScatterDataElements = MAX(m_dataModel->getNumInPrimitives(),
m_dataModel->getNumOutVertices());
m_scatterDataElements = 0;
m_scatterPositions = new float[3 * m_maxScatterDataElements];
m_scatterColorsAndSizes = new float[3 * m_maxScatterDataElements];
m_scatterDataX = m_scatterPositions;
clearData(m_scatterDataX, m_maxScatterDataElements, 3, 0.0f);
m_scatterDataCountX = 0;
m_scatterDataY = m_scatterPositions + 1;
clearData(m_scatterDataY, m_maxScatterDataElements, 3, 0.0f);
m_scatterDataCountY = 0;
m_scatterDataZ = m_scatterPositions + 2;
clearData(m_scatterDataZ, m_maxScatterDataElements, 3, 0.0f);
m_scatterDataCountZ = 0;
m_scatterDataRed = m_scatterColorsAndSizes;
clearData(m_scatterDataRed, m_maxScatterDataElements, 3, 0.0f);
m_scatterDataCountRed = 0;
m_scatterDataGreen = m_scatterColorsAndSizes + 1;
clearData(m_scatterDataGreen, m_maxScatterDataElements, 3, 0.0f);
m_scatterDataCountGreen = 0;
m_scatterDataBlue = m_scatterColorsAndSizes + 2;
clearData(m_scatterDataBlue, m_maxScatterDataElements, 3, 0.0f);
m_scatterDataCountBlue = 0;
m_qGLscatter->setData(m_scatterPositions, m_scatterColorsAndSizes, 0);
on_slPointSize_valueChanged(300);
setupMappingUI();
updateGUI();
}
