/* 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(); }