Changeset 3452


Ignore:
Timestamp:
Mar 4, 2013, 11:57:13 PM (7 years ago)
Author:
ldelgass
Message:

Remove XINETD define from nanovis. We only support server mode now, no glut
interaction loop with mouse/keyboard handlers. Fixes for trace logging to make
output closer to vtkvis: inlcude function name for trace messages, remove
newlines from format strings in macros since newlines get added by syslog.

Location:
trunk/packages/vizservers/nanovis
Files:
38 edited

Legend:

Unmodified
Added
Removed
  • trunk/packages/vizservers/nanovis/Command.cpp

    r3394 r3452  
    508508    }
    509509    Rappture::Outcome err;
    510     TRACE("Checking header[%.13s]\n", buf.bytes());
     510    TRACE("Checking header[%.13s]", buf.bytes());
    511511    if (strncmp (buf.bytes(), "@@RP-ENC:", 9) == 0) {
    512512        /* There's a header on the buffer, use it to decode the data. */
     
    10641064
    10651065            fraction = ((float)frame_num) / (total - 1);
    1066             TRACE("fraction : %f\n", fraction);
     1066            TRACE("fraction : %f", fraction);
    10671067            //interpolator->update(((float)frame_num) / (total - 1));
    10681068            interpolator->update(fraction);
     
    11161116        return TCL_ERROR;
    11171117    }
    1118     TRACE("parsing volume data identifier\n");
     1118    TRACE("parsing volume data identifier");
    11191119    Tcl_HashSearch iter;
    11201120    Tcl_HashEntry *hPtr;
     
    11561156                    Tcl_Obj *const *objv)
    11571157{
    1158     TRACE("Data Loading\n");
     1158    TRACE("Data Loading");
    11591159
    11601160    int nbytes;
     
    11741174    nBytes = buf.size();
    11751175
    1176     TRACE("Checking header[%.20s]\n", bytes);
     1176    TRACE("Checking header[%.20s]", bytes);
    11771177
    11781178    Volume *volPtr = NULL;
    11791179
    11801180    if ((nBytes > 5) && (strncmp(bytes, "<HDR>", 5) == 0)) {
    1181         TRACE("ZincBlende stream is in\n");
     1181        TRACE("ZincBlende stream is in");
    11821182         //std::stringstream fdata(std::ios_base::out|std::ios_base::in|std::ios_base::binary);
    11831183        //fdata.write(buf.bytes(),buf.size());
     
    11891189            return TCL_ERROR;
    11901190        }
    1191         TRACE("finish loading\n");
     1191        TRACE("finish loading");
    11921192
    11931193        Vector3 scale = volPtr->getPhysicalScaling();
     
    12121212            nBytes -= 5;
    12131213        }
    1214         TRACE("DX loading...\n");
     1214        TRACE("DX loading...");
    12151215        std::stringstream fdata;
    12161216        fdata.write(bytes, nBytes);
    12171217        if (nBytes <= 0) {
    1218             ERROR("data buffer is empty\n");
     1218            ERROR("data buffer is empty");
    12191219            abort();
    12201220        }
     
    15021502        return TCL_ERROR;
    15031503    }
    1504     TRACE("set opacity %f\n", opacity);
     1504    TRACE("set opacity %f", opacity);
    15051505    std::vector<Volume *> ivol;
    15061506    if (GetVolumes(interp, objc - 4, objv + 4, &ivol) != TCL_OK) {
     
    15761576    std::vector<Volume *>::iterator iter;
    15771577    for (iter = ivol.begin(); iter != ivol.end(); iter++) {
    1578         TRACE("setting %s with transfer function %s\n", (*iter)->name(),
     1578        TRACE("setting %s with transfer function %s", (*iter)->name(),
    15791579               tfPtr->name());
    15801580        (*iter)->transferFunction(tfPtr);
     
    17291729        hmPtr = (HeightMap *)Tcl_GetHashValue(hPtr);
    17301730    }
    1731     TRACE("Number of heightmaps=%d\n", NanoVis::heightmapTable.numEntries);
     1731    TRACE("Number of heightmaps=%d", NanoVis::heightmapTable.numEntries);
    17321732    // Must set units before the heights.
    17331733    hmPtr->xAxis.units(data.xUnits());
     
    18811881    Tcl_SetStringObj(Tcl_GetObjResult(interp), tag, -1);;
    18821882    NanoVis::eventuallyRedraw();
    1883     TRACE("Number of heightmaps=%d\n", NanoVis::heightmapTable.numEntries);
     1883    TRACE("Number of heightmaps=%d", NanoVis::heightmapTable.numEntries);
    18841884    return TCL_OK;
    18851885}
     
    21422142           Tcl_Obj *const *objv)
    21432143{
    2144     TRACE("load plane for 2D visualization command\n");
     2144    TRACE("load plane for 2D visualization command");
    21452145
    21462146    int index, w, h;
     
    21872187            Tcl_Obj *const *objv)
    21882188{
    2189     TRACE("link the plane to the 2D renderer command\n");
     2189    TRACE("link the plane to the 2D renderer command");
    21902190
    21912191    int plane_index;
     
    22142214              Tcl_Obj *const *objv)
    22152215{
    2216     TRACE("enable a plane so the 2D renderer can render it command\n");
     2216    TRACE("enable a plane so the 2D renderer can render it command");
    22172217
    22182218    if (objc != 3) {
     
    23402340    // create a default transfer function
    23412341    if (Tcl_Eval(interp, def_transfunc) != TCL_OK) {
    2342         WARN("bad default transfer function\n%s\n",
     2342        WARN("bad default transfer function:\n%s",
    23432343             Tcl_GetStringResult(interp));
    23442344    }
  • trunk/packages/vizservers/nanovis/ConvexPolygon.cpp

    r3362 r3452  
    5757{
    5858    if (vertices.size() == 0) {
    59         ERROR("polygon has no vertices\n");
     59        ERROR("polygon has no vertices");
    6060        return false;
    6161    }
     
    144144        }
    145145    } else {
    146         WARN("No polygons to render\n");
     146        WARN("No polygons to render");
    147147    }
    148148}
     
    165165        }
    166166    } else {
    167         WARN("No polygons to render\n");
     167        WARN("No polygons to render");
    168168    }
    169169}
  • trunk/packages/vizservers/nanovis/FlowCmd.cpp

    r3397 r3452  
    154154FlowParticles::render()
    155155{
    156     TRACE("rendering particles %s\n", _name);
    157     TRACE("rendering particles %s axis=%d\n", _name, _sv.position.axis);
    158     TRACE("rendering particles %s position=%g\n", _name, _sv.position.value);
    159     TRACE("rendering particles %s position=%g\n", _name,
     156    TRACE("rendering particles %s", _name);
     157    TRACE("rendering particles %s axis=%d", _name, _sv.position.axis);
     158    TRACE("rendering particles %s position=%g", _name, _sv.position.value);
     159    TRACE("rendering particles %s position=%g", _name,
    160160          FlowCmd::GetRelativePosition(&_sv.position));
    161161
     
    195195FlowBox::Render(Volume *volPtr)
    196196{
    197     TRACE("Rendering box %s\n", _name);
     197    TRACE("Rendering box %s", _name);
    198198
    199199    glPushAttrib(GL_ENABLE_BIT);
     
    220220    max.z = volPtr->zAxis.max();
    221221
    222     TRACE("box is %g,%g %g,%g %g,%g\n",
     222    TRACE("box is %g,%g %g,%g %g,%g",
    223223          _sv.corner1.x, _sv.corner2.x,
    224224          _sv.corner1.y, _sv.corner2.y,
    225225          _sv.corner1.z, _sv.corner2.z);
    226     TRACE("world is %g,%g %g,%g %g,%g\n",
     226    TRACE("world is %g,%g %g,%g %g,%g",
    227227          min.x, max.x, min.y, max.y, min.z, max.z);
    228228
     
    242242        z1 = (_sv.corner2.z - min.z) / (max.z - min.z);
    243243    }
    244     TRACE("rendering box %g,%g %g,%g %g,%g\n", x0, x1, y0, y1, z0, z1);
     244    TRACE("rendering box %g,%g %g,%g %g,%g", x0, x1, y0, y1, z0, z1);
    245245
    246246    glColor4d(_sv.color.r, _sv.color.g, _sv.color.b, _sv.color.a);
     
    381381        }
    382382    }
    383     TRACE("in Render before boxes %s\n", _name);
     383    TRACE("in Render before boxes %s", _name);
    384384    RenderBoxes();
    385385}
     
    531531{
    532532    if (_volPtr != NULL) {
    533         TRACE("from ScaleVectorField volId=%s\n", _volPtr->name());
     533        TRACE("from ScaleVectorField volId=%s", _volPtr->name());
    534534        NanoVis::removeVolume(_volPtr);
    535535        _volPtr = NULL;
     
    613613    FlowBox *boxPtr;
    614614    for (boxPtr = FirstBox(&iter); boxPtr != NULL; boxPtr = NextBox(&iter)) {
    615         TRACE("found box %s\n", boxPtr->name());
     615        TRACE("found box %s", boxPtr->name());
    616616        if (boxPtr->visible()) {
    617617            boxPtr->Render(_volPtr);
     
    667667    volPtr->zAxis.setRange(_dataPtr->zMin(), _dataPtr->zMax());
    668668
    669     TRACE("min=%g %g %g max=%g %g %g mag=%g %g\n",
     669    TRACE("min=%g %g %g max=%g %g %g mag=%g %g",
    670670          NanoVis::xMin, NanoVis::yMin, NanoVis::zMin,
    671671          NanoVis::xMax, NanoVis::yMax, NanoVis::zMax,
     
    706706    const char *fileName;
    707707    fileName = Tcl_GetString(objv[3]);
    708     TRACE("Flow loading data from file %s\n", fileName);
     708    TRACE("Flow loading data from file %s", fileName);
    709709
    710710    int nComponents;
     
    750750        delete u2dPtr;
    751751    } else {
    752         TRACE("header is %.14s\n", buf.bytes());
     752        TRACE("header is %.14s", buf.bytes());
    753753        if (!dataPtr->importDx(result, nComponents, length, bytes)) {
    754754            Tcl_AppendResult(interp, result.remark(), (char *)NULL);
     
    777777    Rappture::Outcome result;
    778778
    779     TRACE("Flow Data Loading\n");
     779    TRACE("Flow Data Loading");
    780780
    781781    int nBytes;
    782782    if (Tcl_GetIntFromObj(interp, objv[3], &nBytes) != TCL_OK) {
    783         ERROR("Bad nBytes \"%s\"\n", Tcl_GetString(objv[3]));
     783        ERROR("Bad nBytes \"%s\"", Tcl_GetString(objv[3]));
    784784        return TCL_ERROR;
    785785    }
     
    787787        Tcl_AppendResult(interp, "bad # bytes request \"",
    788788                         Tcl_GetString(objv[3]), "\" for \"data follows\"", (char *)NULL);
    789         ERROR("Bad nbytes %d\n", nBytes);
     789        ERROR("Bad nbytes %d", nBytes);
    790790        return TCL_ERROR;
    791791    }
    792792    int nComponents;
    793793    if (Tcl_GetIntFromObj(interp, objv[4], &nComponents) != TCL_OK) {
    794         ERROR("Bad # of components \"%s\"\n", Tcl_GetString(objv[4]));
     794        ERROR("Bad # of components \"%s\"", Tcl_GetString(objv[4]));
    795795        return TCL_ERROR;
    796796    }
     
    798798        Tcl_AppendResult(interp, "bad # of components request \"",
    799799                         Tcl_GetString(objv[4]), "\" for \"data follows\"", (char *)NULL);
    800         ERROR("Bad # of components %d\n", nComponents);
     800        ERROR("Bad # of components %d", nComponents);
    801801        return TCL_ERROR;
    802802    }
    803803    Rappture::Buffer buf;
    804     TRACE("Flow Data Loading %d %d\n", nBytes, nComponents);
     804    TRACE("Flow Data Loading %d %d", nBytes, nComponents);
    805805    if (GetDataStream(interp, buf, nBytes) != TCL_OK) {
    806806        return TCL_ERROR;
     
    833833        delete u2dPtr;
    834834    } else {
    835         TRACE("header is %.14s\n", buf.bytes());
     835        TRACE("header is %.14s", buf.bytes());
    836836        if (!dataPtr->importDx(result, nComponents, length, bytes)) {
    837837            Tcl_AppendResult(interp, result.remark(), (char *)NULL);
     
    845845        return TCL_ERROR;
    846846    }
    847     TRACE("nx = %d ny = %d nz = %d\n", dataPtr->xNum(), dataPtr->yNum(), dataPtr->zNum());
    848     TRACE("x0 = %lg y0 = %lg z0 = %lg\n", dataPtr->xMin(), dataPtr->yMin(), dataPtr->zMin());
    849     TRACE("lx = %lg ly = %lg lz = %lg\n",
     847    TRACE("nx = %d ny = %d nz = %d", dataPtr->xNum(), dataPtr->yNum(), dataPtr->zNum());
     848    TRACE("x0 = %lg y0 = %lg z0 = %lg", dataPtr->xMin(), dataPtr->yMin(), dataPtr->zMin());
     849    TRACE("lx = %lg ly = %lg lz = %lg",
    850850          dataPtr->xMax() - dataPtr->xMin(),
    851851          dataPtr->yMax() - dataPtr->yMin(),
    852852          dataPtr->zMax() - dataPtr->zMin());
    853     TRACE("dx = %lg dy = %lg dz = %lg\n",
     853    TRACE("dx = %lg dy = %lg dz = %lg",
    854854          dataPtr->xNum() > 1 ? (dataPtr->xMax() - dataPtr->xMin())/(dataPtr->xNum()-1) : 0,
    855855          dataPtr->yNum() > 1 ? (dataPtr->yMax() - dataPtr->yMin())/(dataPtr->yNum()-1) : 0,
    856856          dataPtr->zNum() > 1 ? (dataPtr->zMax() - dataPtr->zMin())/(dataPtr->zNum()-1) : 0);
    857     TRACE("magMin = %lg magMax = %lg\n",
     857    TRACE("magMin = %lg magMax = %lg",
    858858          dataPtr->magMin(), dataPtr->magMax());
    859859    flowPtr->data(dataPtr);
     
    863863        size_t length;
    864864
    865         length = sprintf(info, "nv>data tag %s min %g max %g\n",
     865        length = sprintf(info, "nv>data tag %s min %g max %g",
    866866                         flowPtr->name(), dataPtr->magMin(), dataPtr->magMax());
    867867        nWritten  = write(1, info, length);
     
    10131013{
    10141014    flags &= ~MAP_FLOWS;
    1015     TRACE("MapFlows\n");
     1015    TRACE("MapFlows");
    10161016
    10171017    /*
     
    10571057        }
    10581058    }
    1059     TRACE("MapFlows magMin=%g magMax=%g\n", NanoVis::magMin, NanoVis::magMax);
     1059    TRACE("MapFlows magMin=%g magMax=%g", NanoVis::magMin, NanoVis::magMax);
    10601060
    10611061    /*
     
    19191919    oldHeight = NanoVis::winHeight;
    19201920
    1921     TRACE("FLOW started\n");
     1921    TRACE("FLOW started");
    19221922
    19231923    Rappture::Outcome context;
     
    19681968    }
    19691969    movie.done(context);
    1970     TRACE("FLOW end\n");
     1970    TRACE("FLOW end");
    19711971    if (!canceled) {
    19721972        Rappture::Buffer data;
  • trunk/packages/vizservers/nanovis/GradientFilter.cpp

    r2877 r3452  
    3636                                     strlen(floatExt) +
    3737                                     strlen(extension) + 1))) {
    38         ERROR("not enough memory for filename\n");
     38        ERROR("not enough memory for filename");
    3939        exit(1);
    4040    }
     
    6060    if (fwrite(gradients, 3 * sizes[0] * sizes[1] * sizes[2] * sizeof(float),
    6161               1, fp) != 1) {
    62         ERROR("writing float gradients failed\n");
     62        ERROR("writing float gradients failed");
    6363        exit(1);
    6464    }
     
    8383
    8484    if (fwrite(gradients, size, 1, fp) != 1) {
    85         ERROR("writing gradients failed\n");
     85        ERROR("writing gradients failed");
    8686        exit(1);
    8787    }
     
    138138            break;
    139139        default:
    140             ERROR("Unsupported data type\n");
     140            ERROR("Unsupported data type");
    141141            exit(1);
    142142            break;
     
    190190    };
    191191
    192     TRACE("computing gradients ... may take a while\n");
     192    TRACE("computing gradients ... may take a while");
    193193
    194194    di = 0;
     
    312312    float sum, *filteredGradients, ****filter;
    313313
    314     TRACE("filtering gradients ... may also take a while\n");
     314    TRACE("filtering gradients ... may also take a while");
    315315
    316316    if (! (filteredGradients = (float *)malloc(sizes[0] * sizes[1] * sizes[2]
    317317                                               * 3 * sizeof(float)))) {
    318         ERROR("not enough memory for filtered gradients\n");
     318        ERROR("not enough memory for filtered gradients");
    319319        exit(1);
    320320    }
     
    323323    if (! (filter = (float ****)malloc((GRAD_FILTER_SIZE/2 + 1) *
    324324                                       sizeof(float ***)))) {
    325         ERROR("failed to allocate gradient filter\n");
     325        ERROR("failed to allocate gradient filter");
    326326        exit(1);
    327327    }
     
    330330        if (! (filter[i] = (float ***)malloc((GRAD_FILTER_SIZE) *
    331331                                             sizeof(float **)))) {
    332             ERROR("failed to allocate gradient filter\n");
     332            ERROR("failed to allocate gradient filter");
    333333            exit(1);
    334334        }
     
    338338            if (! (filter[i][j] = (float **)malloc((GRAD_FILTER_SIZE) *
    339339                                                   sizeof(float *)))) {
    340                 ERROR("failed to allocate gradient filter\n");
     340                ERROR("failed to allocate gradient filter");
    341341                exit(1);
    342342            }
     
    348348                if (! (filter[i][j][k] = (float *)malloc((GRAD_FILTER_SIZE) *
    349349                                                         sizeof(float)))) {
    350                     ERROR("failed to allocate gradient filter\n");
     350                    ERROR("failed to allocate gradient filter");
    351351                    exit(1);
    352352                }
     
    525525                    break;
    526526                default:
    527                     ERROR("unsupported data type\n");
     527                    ERROR("unsupported data type");
    528528                    break;
    529529                }
  • trunk/packages/vizservers/nanovis/Grid.cpp

    r3362 r3452  
    5858    double zoffset = (zAxis.min() - zAxis.dataMin()) * zAxis.scale();
    5959
    60     TRACE("Axis ranges: %g %g %g\n", xAxis.range(), yAxis.range(), zAxis.range());
    61     TRACE("Axis scales: %g %g %g\n", xAxis.scale(), yAxis.scale(), zAxis.scale());
    62     TRACE("Axis min/max: %g,%g %g,%g %g,%g\n",
     60    TRACE("Axis ranges: %g %g %g", xAxis.range(), yAxis.range(), zAxis.range());
     61    TRACE("Axis scales: %g %g %g", xAxis.scale(), yAxis.scale(), zAxis.scale());
     62    TRACE("Axis min/max: %g,%g %g,%g %g,%g",
    6363          xAxis.min(), xAxis.max(),
    6464          yAxis.min(), yAxis.max(),
    6565          zAxis.min(), zAxis.max());
    66     TRACE("Axis vmin/vmax: %g,%g %g,%g %g,%g\n",
     66    TRACE("Axis vmin/vmax: %g,%g %g,%g %g,%g",
    6767          xAxis.dataMin(), xAxis.dataMax(),
    6868          yAxis.dataMin(), yAxis.dataMax(),
    6969          zAxis.dataMin(), zAxis.dataMax());
    70     TRACE("paspect: %g %g %g\n", paspectX, paspectY, paspectZ);
    71     TRACE("scale: %g %g %g\n", xscale, yscale, zscale);
     70    TRACE("paspect: %g %g %g", paspectX, paspectY, paspectZ);
     71    TRACE("scale: %g %g %g", xscale, yscale, zscale);
    7272
    7373    glTranslatef(-0.5f * paspectX, -0.5f * paspectY, -0.5f * paspectZ);
  • trunk/packages/vizservers/nanovis/HeightMap.cpp

    r3362 r3452  
    296296    //else
    297297    //{
    298     //ERROR("HeightMap::setHeight\n");
     298    //ERROR("HeightMap::setHeight");
    299299    //}
    300300}
  • trunk/packages/vizservers/nanovis/Mat4x4.cpp

    r3177 r3452  
    2828Mat4x4::print() const
    2929{
    30     TRACE("%f %f %f %f\n", m[0], m[1], m[2], m[3]);
    31     TRACE("%f %f %f %f\n", m[4], m[5], m[6], m[7]);
    32     TRACE("%f %f %f %f\n", m[8], m[9], m[10], m[11]);
    33     TRACE("%f %f %f %f\n", m[12], m[13], m[14], m[15]);
     30    TRACE("%f %f %f %f", m[0], m[1], m[2], m[3]);
     31    TRACE("%f %f %f %f", m[4], m[5], m[6], m[7]);
     32    TRACE("%f %f %f %f", m[8], m[9], m[10], m[11]);
     33    TRACE("%f %f %f %f", m[12], m[13], m[14], m[15]);
    3434}
    3535
     
    7272
    7373#if 0
    74     TRACE("Invert:\n");
    75     TRACE("   %12.9f %12.9f %12.9f %12.9f\n", m00, m01, m02, m03);
    76     TRACE("   %12.9f %12.9f %12.9f %12.9f\n", m10, m11, m12, m13);
    77     TRACE("   %12.9f %12.9f %12.9f %12.9f\n", m20, m21, m22, m23);
    78     TRACE("   %12.9f %12.9f %12.9f %12.9f\n", m30, m31, m32, m33);
     74    TRACE("Invert:");
     75    TRACE("   %12.9f %12.9f %12.9f %12.9f", m00, m01, m02, m03);
     76    TRACE("   %12.9f %12.9f %12.9f %12.9f", m10, m11, m12, m13);
     77    TRACE("   %12.9f %12.9f %12.9f %12.9f", m20, m21, m22, m23);
     78    TRACE("   %12.9f %12.9f %12.9f %12.9f", m30, m31, m32, m33);
    7979#endif
    8080
  • trunk/packages/vizservers/nanovis/NvCamera.cpp

    r3362 r3452  
    8383    _far = -zMin;
    8484
    85     TRACE("Resetting camera clipping range to: near: %g, far: %g\n", _near, _far);
     85    TRACE("Resetting camera clipping range to: near: %g, far: %g", _near, _far);
    8686
    8787    glMatrixMode(GL_PROJECTION);
     
    9696NvCamera::initialize()
    9797{
    98     TRACE("camera: %d, %d\n", _width, _height);
     98    TRACE("camera: %d, %d", _width, _height);
    9999    glViewport(_startX, _startY, _width, _height);
    100100    glMatrixMode(GL_PROJECTION);
     
    118118    _cameraMatrix.makeRotation(rot);
    119119    _cameraMatrix.transpose();
    120     TRACE("Set rotation to quat: %g %g %g %g\n",
     120    TRACE("Set rotation to quat: %g %g %g %g",
    121121          quat[0], quat[1], quat[2], quat[3]);
    122122}
     
    135135    //_cameraMatrix.transpose();
    136136
    137     TRACE("Set rotation to angles: %g %g %g\n",
     137    TRACE("Set rotation to angles: %g %g %g",
    138138          angleX, angleY, angleZ);
    139139}
  • trunk/packages/vizservers/nanovis/NvEventLog.cpp

    r2836 r3452  
    1616static double cur_time; //in seconds
    1717
    18 #ifdef XINETD
    1918void NvInitService()
    2019{
     
    5352    }
    5453}
    55 #endif
    5654
    5755void NvInitEventLog()
     
    8179    return interval;
    8280}
    83 
  • trunk/packages/vizservers/nanovis/NvLIC.cpp

    r3177 r3452  
    138138NvLIC::makePatterns()
    139139{
    140     TRACE("begin makePatterns\n");
     140    TRACE("Enter");
     141
    141142    if (_disListID > 0) {
    142143        glDeleteLists(_disListID, _Npat);
     
    144145    _disListID = glGenLists(_Npat);
    145146
    146     TRACE("DisplayList : %d\n", _disListID);
     147    TRACE("DisplayList : %d", _disListID);
    147148
    148149    int lut[256];
     
    178179    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, NPN, NPN, 0,
    179180                 GL_RGBA, GL_UNSIGNED_BYTE, pat);
    180     TRACE("finish makePatterns\n");
     181
     182    TRACE("Leave");
    181183}
    182184
     
    489491                      float scaleX, float scaleY, float scaleZ, float max)
    490492{
    491     TRACE("NvLIC: vector field is assigned [%d]\n", texID);
     493    TRACE("NvLIC: vector field is assigned [%d]", texID);
    492494    _vectorFieldId = texID;
    493495    _origin = origin;
     
    536538   *py = y + vy;
    537539
    538     //TRACE("vel %f %f -> %f %f, (dmax = %f)\n", x, y, *px, *py, dmax);
     540    //TRACE("vel %f %f -> %f %f, (dmax = %f)", x, y, *px, *py, dmax);
    539541}
    540542
  • trunk/packages/vizservers/nanovis/NvParticleRenderer.cpp

    r3177 r3452  
    220220    glBindTexture(GL_TEXTURE_RECTANGLE_ARB, 0);
    221221
    222     TRACE("init particles\n");
     222    TRACE("Leave");
    223223}
    224224
  • trunk/packages/vizservers/nanovis/NvShader.cpp

    r2972 r3452  
    4040
    4141    if (lastError) {
    42         TRACE("Cg Error: %s\n", cgGetErrorString(lastError));
     42        TRACE("Cg Error: %s", cgGetErrorString(lastError));
    4343        if (getCgContext())
    44             TRACE("%s\n", cgGetLastListing(getCgContext()));
     44            TRACE("%s", cgGetLastListing(getCgContext()));
    4545        return false;
    4646    }
     
    5454    std::string path = R2FilePath::getInstance()->getPath(fileName);
    5555    if (path.empty()) {
    56         ERROR("can't find program \"%s\"\n", fileName);
     56        ERROR("can't find program \"%s\"", fileName);
    5757    }
    58     TRACE("cg program compiling: %s\n", path.c_str());
     58    TRACE("cg program compiling: %s", path.c_str());
    5959    CGprogram program;
    6060    program = cgCreateProgramFromFile(context, CG_SOURCE, path.c_str(), profile,
     
    6363    CGerror LastError = cgGetError();
    6464    if (LastError) {
    65         ERROR("Error message: %s\n", cgGetLastListing(context));
     65        ERROR("Error message: %s", cgGetLastListing(context));
    6666    }
    67     TRACE("successfully compiled program: %s\n", path.c_str());
     67    TRACE("successfully compiled program: %s", path.c_str());
    6868    return program;
    6969}
     
    110110{
    111111    if (_cgVP != NULL) {
    112         TRACE("Destroying vertex program: %s\n", _vpFile.c_str());
     112        TRACE("Destroying vertex program: %s", _vpFile.c_str());
    113113        cgDestroyProgram(_cgVP);
    114114    }
    115115
    116116    if (_cgFP != NULL) {
    117         TRACE("Destroying fragment program: %s\n", _fpFile.c_str());
     117        TRACE("Destroying fragment program: %s", _fpFile.c_str());
    118118        cgDestroyProgram(_cgFP);
    119119    }
     
    122122void NvShader::setErrorCallback(NvCgCallbackFunction callback)
    123123{
    124     TRACE("NvShader setting error callback to: %p\n", callback);
     124    TRACE("NvShader setting error callback to: %p", callback);
    125125    cgSetErrorCallback(callback);
    126126}
  • trunk/packages/vizservers/nanovis/NvShader.h

    r3362 r3452  
    5050            return cgGetNamedParameter(_cgFP, paramName);
    5151        }
    52         ERROR("Unknown fragment program parameter: %s\n", paramName);
     52        ERROR("Unknown fragment program parameter: %s", paramName);
    5353        return 0;
    5454    }
     
    5959            return cgGetNamedParameter(_cgVP, paramName);
    6060        }
    61         ERROR("Unknown vertex program parameter: %s\n", paramName);
     61        ERROR("Unknown vertex program parameter: %s", paramName);
    6262        return 0;
    6363    }
     
    289289                _vpParams[name] = param;
    290290            else
    291                 ERROR("Unknown vertex program parameter: %s\n", name);
     291                ERROR("Unknown vertex program parameter: %s", name);
    292292        } else {
    293293            param = itr->second;
     
    305305                _fpParams[name] = param;
    306306            else
    307                 ERROR("Unknown fragment program parameter: %s\n", name);
     307                ERROR("Unknown fragment program parameter: %s", name);
    308308        } else {
    309309            param = itr->second;
  • trunk/packages/vizservers/nanovis/NvVectorField.cpp

    r3362 r3452  
    225225        }
    226226
    227         TRACE("rendering box %g,%g %g,%g %g,%g\n", x0, x1, y0, y1, z0, z1);
     227        TRACE("rendering box %g,%g %g,%g %g,%g", x0, x1, y0, y1, z0, z1);
    228228
    229229        glColor4d(shape.color.x, shape.color.y, shape.color.z, shape.color.w);
  • trunk/packages/vizservers/nanovis/NvZincBlendeReconstructor.cpp

    r3362 r3452  
    5454            continue;
    5555        } else if (strstr((const char*) buff, "object") != 0) {
    56             TRACE("VERSION 1\n");
     56            TRACE("VERSION 1");
    5757            version = 1;
    5858            break;
    5959        } else if (strstr(buff, "record format") != 0) {
    60             TRACE("VERSION 2\n");
     60            TRACE("VERSION 2");
    6161            version = 2;
    6262            break;
     
    8989            stream.read((char *)data, width * height * depth * 8 * 4 * sizeof(double));
    9090        } catch (...) {
    91             ERROR("Caught exception trying to read stream\n");
     91            ERROR("Caught exception trying to read stream");
    9292        }
    9393
     
    104104                sscanf(pt, "%s%f%f%f", str[0], &(delta.x), &(delta.y), &(delta.z));
    105105#ifdef _LOADER_DEBUG_
    106                 TRACE("delta : %f %f %f\n", delta.x, delta.y, delta.z);
     106                TRACE("delta : %f %f %f", delta.x, delta.y, delta.z);
    107107#endif
    108108            } else if ((pt = strstr(buff, "datacount")) != 0) {
    109109                sscanf(pt, "%s%d", str[0], &datacount);
    110110#ifdef _LOADER_DEBUG_
    111                 TRACE("datacount = %d\n", datacount);
     111                TRACE("datacount = %d", datacount);
    112112#endif
    113113            } else if ((pt = strstr(buff, "datatype")) != 0) {
     
    118118                sscanf(pt, "%s%d%d%d", str[0], &width, &height, &depth);
    119119#ifdef _LOADER_DEBUG_
    120                 TRACE("width height depth %d %d %d\n", width, height, depth);
     120                TRACE("width height depth %d %d %d", width, height, depth);
    121121#endif
    122122            } else if ((pt = strstr(buff, "emptymark")) != 0) {
    123123                sscanf(pt, "%s%lf", str[0], &emptyvalue);
    124124#ifdef _LOADER_DEBUG_
    125                 TRACE("emptyvalue %lf\n", emptyvalue);
     125                TRACE("emptyvalue %lf", emptyvalue);
    126126#endif
    127127            } else if ((pt = strstr(buff, "emprymark")) != 0) {
    128128                sscanf(pt, "%s%lf", str[0], &emptyvalue);
    129129#ifdef _LOADER_DEBUG_
    130                 TRACE("emptyvalue %lf\n", emptyvalue);
     130                TRACE("emptyvalue %lf", emptyvalue);
    131131#endif
    132132            }
     
    217217
    218218#ifdef _LOADER_DEBUG_
    219         TRACE("index %d\n", index);
     219        TRACE("index %d", index);
    220220#endif
    221221
     
    287287
    288288#ifdef _LOADER_DEBUG_
    289         TRACE("[%d] index %d (width:%lf height:%lf depth:%lf)\n", i, index, srcPtr->indexX, srcPtr->indexY, srcPtr->indexZ);
     289        TRACE("[%d] index %d (width:%lf height:%lf depth:%lf)", i, index, srcPtr->indexX, srcPtr->indexY, srcPtr->indexZ);
    290290#endif
    291291
    292292        if (index < 0) {
    293293#ifdef _LOADER_DEBUG_
    294             TRACE("There is an invalid data\n");
     294            TRACE("There is an invalid data");
    295295#endif
    296296            srcPtr +=8;
     
    377377            continue;
    378378        } else if (strstr((const char *)buff, "object") != 0) {
    379             TRACE("VERSION 1\n");
     379            TRACE("VERSION 1");
    380380            version = 1;
    381381            break;
    382382        } else if (strstr(buff, "record format") != 0) {
    383             TRACE("VERSION 2\n");
     383            TRACE("VERSION 2");
    384384            version = 2;
    385385            break;
     
    422422                sscanf(pt, "%s%f%f%f", str[0], &(delta.x), &(delta.y), &(delta.z));
    423423#ifdef _LOADER_DEBUG_
    424                 TRACE("delta : %f %f %f\n", delta.x, delta.y, delta.z);
     424                TRACE("delta : %f %f %f", delta.x, delta.y, delta.z);
    425425#endif
    426426            } else if ((pt = strstr(buff, "datacount")) != 0) {
    427427                sscanf(pt, "%s%d", str[0], &datacount);
    428                 TRACE("datacount = %d\n", datacount);
     428                TRACE("datacount = %d", datacount);
    429429            } else if ((pt = strstr(buff, "datatype")) != 0) {
    430430                sscanf(pt, "%s%s", str[0], str[1]);
     
    434434                sscanf(pt, "%s%d%d%d", str[0], &width, &height, &depth);
    435435#ifdef _LOADER_DEBUG_
    436                 TRACE("width height depth %d %d %d\n", width, height, depth);
     436                TRACE("width height depth %d %d %d", width, height, depth);
    437437#endif
    438438            } else if ((pt = strstr(buff, "emptymark")) != 0) {
    439439                sscanf(pt, "%s%lf", str[0], &emptyvalue);
    440440#ifdef _LOADER_DEBUG_
    441                 TRACE("emptyvalue %lf\n", emptyvalue);
     441                TRACE("emptyvalue %lf", emptyvalue);
    442442#endif
    443443            } else if ((pt = strstr(buff, "emprymark")) != 0) {
    444444                sscanf(pt, "%s%lf", str[0], &emptyvalue);
    445445#ifdef _LOADER_DEBUG_
    446                 TRACE("emptyvalue %lf\n", emptyvalue);
     446                TRACE("emptyvalue %lf", emptyvalue);
    447447#endif
    448448            }
  • trunk/packages/vizservers/nanovis/PCASplit.cpp

    r2844 r3452  
    129129    _clusterHeader->startPointerCluster[level - 1] = clusterBlock;
    130130
    131     TRACE("Cluster created %d [in level %d]:total %d\n", count, level, cc);
     131    TRACE("Cluster created %d [in level %d]:total %d", count, level, cc);
    132132
    133133    int i = 0;
     
    142142    }
    143143    if (count != i) {
    144         ERROR("Problem walking clusterList: count: %d, i: %d\n", count, i);
     144        ERROR("Problem walking clusterList: count: %d, i: %d", count, i);
    145145    }
    146146    return clusterBlock;
     
    270270
    271271    if (left == 0 || right == count - 1) {
    272         TRACE("error\n");
     272        TRACE("error");
    273273        exit(1);
    274274    } else {
  • trunk/packages/vizservers/nanovis/ParticleSystem.cpp

    r2972 r3452  
    9191#ifdef WANT_TRACE
    9292                float ti = clock() / (float) CLOCKS_PER_SEC;
    93                 TRACE("LoadProcessedFlowRaw time: %f\n", ti - t);
     93                TRACE("LoadProcessedFlowRaw time: %f", ti - t);
    9494#endif
    9595                queue.push();
    96                 TRACE("%d loaded\n", curIndex);
     96                TRACE("%d loaded", curIndex);
    9797                ++curIndex;
    9898            }
     
    311311                delete image;
    312312            } else {
    313                 ERROR("Failed to load image: arrows.bmp\n");
     313                ERROR("Failed to load image: arrows.bmp");
    314314            }
    315315            delete loader;
    316316        } else {
    317             ERROR("Couldn't find loader for arrows.bmp\n");
     317            ERROR("Couldn't find loader for arrows.bmp");
    318318        }
    319319    } else {
    320         ERROR("Couldn't find path to arrows.bmp\n");
     320        ERROR("Couldn't find path to arrows.bmp");
    321321    }
    322322
     
    10081008#ifdef WANT_TRACE
    10091009                    float ti = clock() / (float) CLOCKS_PER_SEC;
    1010                     TRACE("updatePixels time: %f\n", ti - t);
     1010                    TRACE("updatePixels time: %f", ti - t);
    10111011#endif
    10121012                    _queue.pop();
     
    10141014
    10151015                    firstLoad = false;
    1016                     TRACE("%d bound\n", index++);
     1016                    TRACE("%d bound", index++);
    10171017                }
    10181018            }           
     
    11921192    glBegin(GL_POINTS);
    11931193    for (iter = _newParticles.begin(); iter != _newParticles.end(); iter++) {
    1194         //TRACE("[%d] %f %f %f\n", iter->index, iter->position.x,iter->position.y,iter->position.z);
     1194        //TRACE("[%d] %f %f %f", iter->index, iter->position.x,iter->position.y,iter->position.z);
    11951195        glMultiTexCoord3f(GL_TEXTURE0, iter->position.x,iter->position.y,iter->position.z);
    11961196
     
    12011201        glVertex2f((float)(iter->index % _width),
    12021202                   (float)(iter->index / _height) + 1/* + offsetY*/ /* + offsetY shouldn't be */);
    1203         //TRACE("%f %f\n", (float) (iter->index % _width), (float)(iter->index / _width));
     1203        //TRACE("%f %f", (float) (iter->index % _width), (float)(iter->index / _width));
    12041204    }
    12051205    glEnd();
     
    12461246    glBegin(GL_POINTS);
    12471247    for (iter = _newParticles.begin(); iter != _newParticles.end(); iter++) {
    1248         //TRACE("[%d] %f %f %f\n", iter->index, iter->position.x,iter->position.y,iter->position.z);
     1248        //TRACE("[%d] %f %f %f", iter->index, iter->position.x,iter->position.y,iter->position.z);
    12491249        glMultiTexCoord3f(GL_TEXTURE0, iter->position.x,iter->position.y,iter->position.z);
    12501250
     
    12551255        glVertex2f((float)(iter->index % _width),
    12561256                   (float)(iter->index / _height) + 1/* + offsetY*/ /* + offsetY shouldn't be */);
    1257         //TRACE("%f %f\n", (float) (iter->index % _width), (float)(iter->index / _width));
     1257        //TRACE("%f %f", (float) (iter->index % _width), (float)(iter->index / _width));
    12581258    }
    12591259    glEnd();
     
    13501350        TRACE("[%d]", _currentSortIndex);
    13511351        for (int i = 0; i < _width * _height * 3; i += 3)
    1352             TRACE("%.2f, %.2f, %.2f\n", debug[i], debug[i+1], debug[i+2]);
    1353         TRACE("\n");
     1352            TRACE("%.2f, %.2f, %.2f", debug[i], debug[i+1], debug[i+2]);
    13541353        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
    13551354    }
     
    13621361        static float debug[256];
    13631362        glReadPixels(0, 0, _width, _height, GL_RGB, GL_FLOAT, (float*)debug);
    1364         TRACE("\n");
    13651363        TRACE("currentPos[%d]", _currentPosIndex);
    13661364        for (int i = 0; i < _width * _height * 3; i += 3)
    1367             TRACE("%.2f, %.2f, %.2f\n", debug[i], debug[i+1], debug[i+2]);
    1368         TRACE("\n");
    1369         glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
     1365            TRACE("%.2f, %.2f, %.2f", debug[i], debug[i+1], debug[i+2]);
     1366         glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
    13701367    }
    13711368    */
     
    13981395        static float debug[256];
    13991396        glReadPixels(0, 0, _width, _height, GL_RGB, GL_FLOAT, (float*)debug);
    1400         TRACE("\n");
    14011397        TRACE("[%d]", _currentSortIndex);
    14021398        for (int i = 0; i < _width * _height * 3; i += 3)
    1403             TRACE("%.2f, %.2f, %.2f\n", debug[i], debug[i+1], debug[i+2]);
    1404         TRACE("\n");
     1399            TRACE("%.2f, %.2f, %.2f", debug[i], debug[i+1], debug[i+2]);
    14051400        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
    14061401    }
     
    14571452        static float debug[256];
    14581453        glReadPixels(0, 0, _width, _height, GL_RGB, GL_FLOAT, (float*)debug);
    1459         TRACE("\n");
    14601454        TRACE("[%d]", _currentSortIndex);
    14611455        for (int i = 0; i < _width * _height * 3; i += 3)
    1462             TRACE("%.2f, %.2f, %.2f\n", debug[i], debug[i+1], debug[i+2]);
    1463         TRACE("\n");
     1456            TRACE("%.2f, %.2f, %.2f", debug[i], debug[i+1], debug[i+2]);
    14641457        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
    14651458    }
     
    16361629
    16371630            cgSetParameter1f(_mvCurrentTimeParam, _currentTime);
    1638             //TRACE("%f %f, %f %d\n", _fov, tan(_fov), tan(_fov / 2.0), _screenHeight);
     1631            //TRACE("%f %f, %f %d", _fov, tan(_fov), tan(_fov / 2.0), _screenHeight);
    16391632            //cgSetParameter1f(_mvTanHalfFOVParam, -tan(_fov * M_PI / 180 * 0.5) * _screenHeight * 0.5);
    16401633            //float v = tan(_fov * M_PI / 180 * 0.5) * _screenHeight * 0.5;
  • trunk/packages/vizservers/nanovis/ParticleSystemFactory.cpp

    r2972 r3452  
    6464        stat = XML_ParseBuffer(parser, (int) cnt, 0);
    6565        if (!stat) {
    66             //TRACE("Parse error at line %d\n", XML_GetCurrentLineNumber(parser));
     66            //TRACE("Parse error at line %d", XML_GetCurrentLineNumber(parser));
    6767            break;
    6868        }
     
    151151                index = path.rfind('\\');
    152152                if (index == -1) {
    153                     TRACE("file not found\n");
     153                    TRACE("file not found");
    154154                }
    155155            }
  • trunk/packages/vizservers/nanovis/PerfQuery.h

    r3177 r3452  
    5454{
    5555    if (!GLEW_ARB_occlusion_query) {
    56         TRACE("ARB_occlusion_query extension not supported\n");
     56        TRACE("ARB_occlusion_query extension not supported");
    5757        return false;
    5858    }
     
    6161                    &bitsSupported);
    6262    if (bitsSupported == 0) {
    63         TRACE("occlusion query not supported!\n");
     63        TRACE("occlusion query not supported!");
    6464        return false;
    6565    } else {
    66         TRACE("Occlusion query with %d bits supported\n", bitsSupported);
     66        TRACE("Occlusion query with %d bits supported", bitsSupported);
    6767        return true;
    6868    }
  • trunk/packages/vizservers/nanovis/PointSetRenderer.cpp

    r2972 r3452  
    1919    std::string path = R2FilePath::getInstance()->getPath("particle2.bmp");
    2020    if (path.empty()) {
    21         ERROR("Particle image not found\n");
     21        ERROR("Particle image not found");
    2222        return;
    2323    }
     
    3939                                      4, image->getImageBuffer());
    4040    } else {
    41         ERROR("Failed to load particle image\n");
     41        ERROR("Failed to load particle image");
    4242    }
    4343
  • trunk/packages/vizservers/nanovis/RenderVertexArray.cpp

    r3362 r3452  
    5757        break;
    5858    default:
    59         ERROR("unsupported RenderVertexArray type\n");
     59        ERROR("unsupported RenderVertexArray type");
    6060        return;
    6161    }
     
    8181        break;
    8282    default:
    83         ERROR("unsupported RenderVertexArray size\n");
     83        ERROR("unsupported RenderVertexArray size");
    8484        return;
    8585    }
  • trunk/packages/vizservers/nanovis/Texture1D.cpp

    r3177 r3452  
    105105    glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max);
    106106
    107     TRACE("max texture size: %d\n", max);
     107    TRACE("max texture size: %d", max);
    108108}
    109109
     
    113113    glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &max);
    114114
    115     TRACE("max texture units: %d.\n", max);
     115    TRACE("max texture units: %d", max);
    116116}
  • trunk/packages/vizservers/nanovis/Texture2D.cpp

    r3177 r3452  
    135135    glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max);
    136136       
    137     TRACE("max texture size: %d\n", max);
     137    TRACE("max texture size: %d", max);
    138138}
    139139
     
    143143    glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &max);
    144144
    145     TRACE("max texture units: %d.\n", max);
     145    TRACE("max texture units: %d", max);
    146146}
  • trunk/packages/vizservers/nanovis/Texture3D.cpp

    r3362 r3452  
    145145    glGetIntegerv(GL_MAX_3D_TEXTURE_SIZE_EXT, &max);
    146146
    147     TRACE("max 3d texture size: %d\n", max);
     147    TRACE("max 3d texture size: %d", max);
    148148}
    149149
     
    153153    glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &max);
    154154
    155     TRACE("max texture units: %d.\n", max);
     155    TRACE("max texture units: %d", max);
    156156}
  • trunk/packages/vizservers/nanovis/Trace.cpp

    r2831 r3452  
    11/* -*- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil -*- */
     2/*
     3 * Copyright (C) 2004-2013  HUBzero Foundation, LLC
     4 *
     5 * Author: George A. Howlett <gah@purdue.edu>
     6 */
    27#include <stdio.h>
    38#include <stdarg.h>
     
    914#include "Trace.h"
    1015
    11 static const char *syslogLevels[] = {
    12     "emergency",                        /* System is unusable */
    13     "alert",                            /* Action must be taken immediately */
    14     "critical",                         /* Critical conditions */
    15     "error",                            /* Error conditions */
    16     "warning",                          /* Warning conditions */
    17     "notice",                           /* Normal but significant condition */
    18     "info",                             /* Informational */
    19     "debug",                            /* Debug-level messages */
    20 };
     16#define MSG_LEN 2047
    2117
    2218void
    23 LogMessage(int priority, const char *path, int lineNum, const char* fmt, ...)
     19LogMessage(int priority, const char *funcname,
     20           const char *path, int lineNum, const char* fmt, ...)
    2421{
    25 #define MSG_LEN (2047)
    2622    char message[MSG_LEN+1];
    2723    const char *s;
     
    3632        s++;
    3733    }
    38     length = snprintf(message, MSG_LEN, "%s: %s:%d ",
    39                       syslogLevels[priority], s, lineNum);
     34    if (priority & LOG_DEBUG) {
     35        length = snprintf(message, MSG_LEN, "%s:%d(%s): ", s, lineNum, funcname);
     36    } else {
     37        length = snprintf(message, MSG_LEN, "%s:%d: ", s, lineNum);
     38    }
    4039    length += vsnprintf(message + length, MSG_LEN - length, fmt, lst);
    4140    message[MSG_LEN] = '\0';
    42     syslog(priority, message, length);
     41
     42    syslog(priority, "%s", message);
    4343}
    4444
     
    7272        mesg = "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT";             break;
    7373    default:
    74         TRACE("FB Status: %s: UNKNOWN framebuffer status %u\n",
     74        TRACE("FB Status: %s: UNKNOWN framebuffer status %u",
    7575               prefix, (unsigned int)status);
    7676        return;
    7777    }
    78     TRACE("FB Status: %s: %s\n", prefix, mesg);
     78    TRACE("FB Status: %s: %s", prefix, mesg);
    7979}
    8080
     
    102102        mesg = "GL_INVALID_FRAMEBUFFER_OPERATION_EXT";  break;
    103103    default:
    104         TRACE("GL Status: %s: Unknown status %d\n", prefix, status);
     104        TRACE("GL Status: %s: Unknown status %d", prefix, status);
    105105        return false;
    106106    }
    107     TRACE("GL Status: %s: %s\n", prefix, mesg);
     107    TRACE("GL Status: %s: %s", prefix, mesg);
    108108    return false;
    109109}
  • trunk/packages/vizservers/nanovis/Trace.h

    r2841 r3452  
    11/* -*- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil -*- */
     2/*
     3 * Copyright (C) 2004-2013  HUBzero Foundation, LLC
     4 *
     5 * Author: George A. Howlett <gah@purdue.edu>
     6 */
     7
    28#ifndef __TRACE_H__
    39#define __TRACE_H__
     
    1218#define AT __FILE__ ":" NEWSTRING(__LINE__)
    1319
    14 extern void LogMessage(int priority, const char *fileName, int lineNum,
    15                         const char* format, ...);
     20extern void LogMessage(int priority, const char *funcname, const char *fileName,
     21                       int lineNum, const char* format, ...);
    1622
    17 #define ERROR(...)      LogMessage(LOG_ERR, __FILE__, __LINE__, __VA_ARGS__)
     23#define ERROR(...)      LogMessage(LOG_ERR, __FUNCTION__, __FILE__, __LINE__, __VA_ARGS__)
    1824#ifdef WANT_TRACE
    19 #define TRACE(...)      LogMessage(LOG_DEBUG, __FILE__, __LINE__, __VA_ARGS__)
     25#define TRACE(...)      LogMessage(LOG_DEBUG, __FUNCTION__, __FILE__, __LINE__, __VA_ARGS__)
    2026#else
    2127#define TRACE(...)
    2228#endif
    23 #define WARN(...)       LogMessage(LOG_WARNING, __FILE__, __LINE__, __VA_ARGS__)
    24 #define INFO(...)       LogMessage(LOG_INFO, __FILE__, __LINE__, __VA_ARGS__)
    25 
     29#define WARN(...)       LogMessage(LOG_WARNING, __FUNCTION__, __FILE__, __LINE__, __VA_ARGS__)
     30#define INFO(...)       LogMessage(LOG_INFO, __FUNCTION__, __FILE__, __LINE__, __VA_ARGS__)
    2631
    2732extern bool CheckFBO(GLenum *statusPtr);
  • trunk/packages/vizservers/nanovis/Unirect.cpp

    r2953 r3452  
    225225    }
    226226    if ((size_t)nValues != (num[0] * num[1] * num[2] * _nComponents)) {
    227         TRACE("num[0]=%d num[1]=%d num[2]=%d ncomponents=%d nValues=%d\n",
     227        TRACE("num[0]=%d num[1]=%d num[2]=%d ncomponents=%d nValues=%d",
    228228               num[0], num[1], num[2], _nComponents, nValues);
    229229        Tcl_AppendResult(interp,
     
    465465   
    466466    if ((axis[0] != 1) || (axis[1] != 0)) {
    467         TRACE("reordering data\n");
     467        TRACE("reordering data");
    468468        /* Reorder the data into x, y where x varies fastest and so on. */
    469469        size_t y;
     
    535535                return false;
    536536            }
    537             TRACE("#points=%d\n", npts);
     537            TRACE("#points=%d", npts);
    538538            if (npts != nx*ny*nz) {
    539539                result.addError("inconsistent data: expected %d points"
     
    683683    dz = lz/(double)(_zNum-1);
    684684
    685     TRACE("lx:%lf ly:%lf lz:%lf dmin:%lf dx:%lf dy:%lf dz:%lf\n", lx, ly, lz, dmin, dx, dy, dz);
     685    TRACE("lx:%lf ly:%lf lz:%lf dmin:%lf dx:%lf dy:%lf dz:%lf", lx, ly, lz, dmin, dx, dy, dz);
    686686
    687687    size_t n = _nComponents * _xNum * _yNum * _zNum;
     
    734734        }
    735735    }
    736     TRACE("getVectorRange: %g %g\n", _magMin, _magMax);
     736    TRACE("getVectorRange: %g %g", _magMin, _magMax);
    737737}
    738738
  • trunk/packages/vizservers/nanovis/Vector3.h

    r3362 r3452  
    4141    void print() const
    4242    {
    43         TRACE("(x:%f, y:%f, z:%f)\n", x, y, z);
     43        TRACE("(x:%f, y:%f, z:%f)", x, y, z);
    4444    }
    4545
  • trunk/packages/vizservers/nanovis/Vector4.h

    r3362 r3452  
    4545    void print() const
    4646    {
    47         TRACE("Vector4: (%.3f, %.3f, %.3f, %.3f)\n", x, y, z, w);
     47        TRACE("Vector4: (%.3f, %.3f, %.3f, %.3f)", x, y, z, w);
    4848    }
    4949
     
    140140        }
    141141        // No solution
    142         TRACE("No intersection between line and plane\n");
     142        TRACE("No intersection between line and plane");
    143143        return false;
    144144    }
  • trunk/packages/vizservers/nanovis/VelocityArrowsSlice.cpp

    r3362 r3452  
    7979                delete image;
    8080            } else {
    81                 ERROR("Failed to load arrows image\n");
     81                ERROR("Failed to load arrows image");
    8282            }
    8383            delete loader;
    8484        } else {
    85             ERROR("Couldn't find loader for arrows image\n");
     85            ERROR("Couldn't find loader for arrows image");
    8686        }
    8787    } else {
    88         ERROR("Couldn't find arrows image\n");
     88        ERROR("Couldn't find arrows image");
    8989    }
    9090
    9191    GLfloat minMax[2];
    9292    glGetFloatv(GL_ALIASED_POINT_SIZE_RANGE, minMax);
    93     TRACE("Aliased point size range: %g %g\n", minMax[0], minMax[1]);
     93    TRACE("Aliased point size range: %g %g", minMax[0], minMax[1]);
    9494    _maxPointSize = minMax[1];
    9595    glGetFloatv(GL_SMOOTH_POINT_SIZE_RANGE, minMax);
    96     TRACE("Smooth point size range: %g %g\n", minMax[0], minMax[1]);
     96    TRACE("Smooth point size range: %g %g", minMax[0], minMax[1]);
    9797    _maxPointSize = minMax[1] > _maxPointSize ? minMax[1] : _maxPointSize;
    98     TRACE("Max point size: %g\n", _maxPointSize);
    99 
    100     TRACE("Leaving VelocityArrowsSlice constructor\n");
     98    TRACE("Max point size: %g", _maxPointSize);
     99
     100    TRACE("Leaving VelocityArrowsSlice constructor");
    101101}
    102102
     
    301301    }
    302302
    303     TRACE("_vf: %g %g %g\n", _vfXscale,_vfYscale, _vfZscale);
    304     TRACE("_maxVelocityScale: %g %g %g\n",
     303    TRACE("_vf: %g %g %g", _vfXscale,_vfYscale, _vfZscale);
     304    TRACE("_maxVelocityScale: %g %g %g",
    305305          _maxVelocityScale.x, _maxVelocityScale.y, _maxVelocityScale.z);
    306306
     
    354354                double length = vel.length();
    355355                if (length < 0.0 || length > 1.0) {
    356                     TRACE("***vec: (%g, %g, %g) length: %g***\n", vel.x, vel.y, vel.z, length);
     356                    TRACE("***vec: (%g, %g, %g) length: %g***", vel.x, vel.y, vel.z, length);
    357357                    continue;
    358358                }
     
    519519    _maxVelocityScale.z = (1.0f / _tickCountZ) * 0.8f;
    520520
    521     TRACE("Tick counts: %d %d %d\n", _tickCountX, _tickCountY, _tickCountZ);
     521    TRACE("Tick counts: %d %d %d", _tickCountX, _tickCountY, _tickCountZ);
    522522
    523523    int pointCount = _tickCountX * _tickCountY * _tickCountZ;
  • trunk/packages/vizservers/nanovis/Volume.cpp

    r3362 r3452  
    5353    _isosurface(0)
    5454{
    55     TRACE("Enter Volume(): %dx%dx%d\n", _width, _height, _depth);
     55    TRACE("Enter: %dx%dx%d", _width, _height, _depth);
    5656
    5757    _tex = new Texture3D(_width, _height, _depth, GL_FLOAT, GL_LINEAR, n);
     
    5959    _data = new float[fcount];
    6060    if (data != NULL) {
    61         TRACE("data is copied\n");
     61        TRACE("data is copied");
    6262        memcpy(_data, data, fcount * sizeof(float));
    6363        _tex->initialize(_data);
    6464    } else {
    65         TRACE("data is null\n");
     65        TRACE("data is null");
    6666        memset(_data, 0, sizeof(_width * _height * _depth * _numComponents *
    6767                                sizeof(float)));
     
    8080    addCutplane(3, 0.5f);
    8181
    82     TRACE("Leave Volume()\n");
     82    TRACE("Leave");
    8383}
    8484
    8585Volume::~Volume()
    8686{
    87     TRACE("In ~Volume()");
     87    TRACE("Enter");
    8888
    8989    delete [] _data;
  • trunk/packages/vizservers/nanovis/VolumeInterpolator.cpp

    r3362 r3452  
    2525{
    2626    if (_volumes.size() > 0) {
    27         TRACE("\tVolume Interpolation Started\n");
     27        TRACE("Volume Interpolation Started");
    2828        _started = true;
    2929    } else {
    30         TRACE("\tVolume Interpolation did not get started\n");
     30        TRACE("Volume Interpolation NOT Started");
    3131        _started = false;
    3232    }
     
    3434    gettimeofday(&clock, NULL);
    3535    _startTime = clock.tv_sec + clock.tv_usec/1000000.0;
    36     TRACE("End Start - VolumeInterpolator\n");
     36    TRACE("Leave");
    3737}
    3838
     
    9898        }
    9999
    100         TRACE("n = %d count = %d\n", n, count);
     100        TRACE("n = %d count = %d", n, count);
    101101        if (n >= limit) {
    102102            *key1 = *key2 = limit;
     
    125125            _volumes[0]->depth() != refPtr->depth() ||
    126126            _volumes[0]->numComponents() != refPtr->numComponents()) {
    127             TRACE("The volume should be the same width, height, number of components\n");
     127            TRACE("The volume should be the same width, height, number of components");
    128128            return;
    129129        }
     
    155155        _volume->opacityScale(refPtr->opacityScale());
    156156        _volume->isosurface(0);
    157         TRACE("VOL : location %f %f %f\n\tid : %s\n", loc.x, loc.y, loc.z,
     157        TRACE("VOL : location %f %f %f\n\tid : %s", loc.x, loc.y, loc.z,
    158158               refPtr->name());
    159159    }
    160160    _volumes.push_back(_volume);
    161     TRACE("a Volume[%s] is added to VolumeInterpolator\n", refPtr->name());
     161    TRACE("a Volume[%s] is added to VolumeInterpolator", refPtr->name());
    162162}
    163163
  • trunk/packages/vizservers/nanovis/VolumeRenderer.cpp

    r3362 r3452  
    129129    float *z_steps = new float[volumes.size()];
    130130
    131     TRACE("start loop %d\n", volumes.size());
     131    TRACE("start loop %d", volumes.size());
    132132    for (size_t i = 0; i < volumes.size(); i++) {
    133133        Volume *volPtr = volumes[i];
     
    145145        Vector3 volScaling = volPtr->getPhysicalScaling();
    146146
    147         TRACE("VOL POS: %g %g %g\n",
     147        TRACE("VOL POS: %g %g %g",
    148148              volPos.x, volPos.y, volPos.z);
    149         TRACE("VOL SCALE: %g %g %g\n",
     149        TRACE("VOL SCALE: %g %g %g",
    150150              volScaling.x, volScaling.y, volScaling.z);
    151151
     
    352352        }
    353353    } //iterate all volumes
    354     TRACE("end loop\n");
     354    TRACE("end loop");
    355355
    356356    // We sort all the polygons according to their eye-space depth, from
     
    401401
    402402#ifdef notdef
    403         TRACE("shading slice: volume %s addr=%x slice=%d, volume=%d z_step=%g avgSD=%g\n",
     403        TRACE("shading slice: volume %s addr=%x slice=%d, volume=%d z_step=%g avgSD=%g",
    404404              volPtr->name(), volPtr, slice_index, volume_index, z_step, avgSampleDistance);
    405405#endif
  • trunk/packages/vizservers/nanovis/config.h

    r3394 r3452  
    3838
    3939/*
    40  * Enable render server
    41  */
    42 #define XINETD
    43 
    44 /*
    4540 * Enable event logging
    4641 */
  • trunk/packages/vizservers/nanovis/define.h

    r3177 r3452  
    2525    switch(status) {                                            \
    2626    case GL_FRAMEBUFFER_COMPLETE_EXT:                           \
    27         TRACE("framebuffer complete!\n");                       \
     27        TRACE("framebuffer complete!");                         \
    2828        break;                                                  \
    2929    case GL_FRAMEBUFFER_UNSUPPORTED_EXT:                        \
    30         TRACE("framebuffer GL_FRAMEBUFFER_UNSUPPORTED_EXT\n");  \
     30        TRACE("framebuffer GL_FRAMEBUFFER_UNSUPPORTED_EXT");    \
    3131        assert(0);                                              \
    3232        break;                                                  \
    3333    case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT:              \
    34         TRACE("framebuffer INCOMPLETE_ATTACHMENT\n");           \
     34        TRACE("framebuffer INCOMPLETE_ATTACHMENT");             \
    3535        break;                                                  \
    3636    case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT:      \
    37         TRACE("framebuffer FRAMEBUFFER_MISSING_ATTACHMENT\n");  \
     37        TRACE("framebuffer FRAMEBUFFER_MISSING_ATTACHMENT");    \
    3838        break;                                                  \
    3939    case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT:              \
    40         TRACE("framebuffer FRAMEBUFFER_DIMENSIONS\n");          \
     40        TRACE("framebuffer FRAMEBUFFER_DIMENSIONS");            \
    4141        break;                                                  \
    4242    case GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT:                 \
    43         TRACE("framebuffer INCOMPLETE_FORMATS\n");              \
     43        TRACE("framebuffer INCOMPLETE_FORMATS");                \
    4444        break;                                                  \
    4545    case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT:             \
    46         TRACE("framebuffer INCOMPLETE_DRAW_BUFFER\n");          \
     46        TRACE("framebuffer INCOMPLETE_DRAW_BUFFER");            \
    4747        break;                                                  \
    4848    case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT:             \
    49         TRACE("framebuffer INCOMPLETE_READ_BUFFER\n");          \
     49        TRACE("framebuffer INCOMPLETE_READ_BUFFER");            \
    5050        break;                                                  \
    5151    case GL_FRAMEBUFFER_BINDING_EXT:                            \
    52         TRACE("framebuffer BINDING_EXT\n");                     \
     52        TRACE("framebuffer BINDING_EXT");                       \
    5353        break;                                                  \
    5454    default:                                                    \
    55         ERROR("unknown framebuffer error %d\n", status);        \
     55        ERROR("unknown framebuffer error %d", status);          \
    5656        /* programming error; will fail on all hardware */      \
    5757        assert(0);                                              \
  • trunk/packages/vizservers/nanovis/dxReader.cpp

    r3362 r3452  
    6363                   std::iostream& fin)
    6464{
    65     TRACE("load_volume_stream %s\n", tag);
     65    TRACE("load_volume_stream %s", tag);
    6666
    6767    Rappture::MeshTri2D xymesh;
     
    213213    }
    214214
    215     TRACE("found nx=%d ny=%d nxy=%d nz=%d\ndx=%f dy=%f dz=%f\nx0=%f y0=%f z0=%f\n",
     215    TRACE("found nx=%d ny=%d nxy=%d nz=%d\ndx=%f dy=%f dz=%f\nx0=%f y0=%f z0=%f",
    216216          nx, ny, nxy, nz, dx, dy, dz, x0, y0, z0);
    217217
     
    257257#ifdef notdef
    258258                if (isnan(dval[p])) {
    259                     TRACE("Found NAN in input at %d,%d,%d\n", ix, iy, iz);
     259                    TRACE("Found NAN in input at %d,%d,%d", ix, iy, iz);
    260260                }
    261261#endif
     
    488488    }
    489489
    490     TRACE("nx = %i ny = %i nz = %i\n", nx, ny, nz);
    491     TRACE("x0 = %lg y0 = %lg z0 = %lg\n", x0, y0, z0);
    492     TRACE("lx = %lg ly = %lg lz = %lg\n", lx, ly, lz);
    493     TRACE("dx = %lg dy = %lg dz = %lg\n", dx, dy, dz);
    494     TRACE("dataMin = %lg dataMax = %lg nzero_min = %lg\n",
     490    TRACE("nx = %i ny = %i nz = %i", nx, ny, nz);
     491    TRACE("x0 = %lg y0 = %lg z0 = %lg", x0, y0, z0);
     492    TRACE("lx = %lg ly = %lg lz = %lg", lx, ly, lz);
     493    TRACE("dx = %lg dy = %lg dz = %lg", dx, dy, dz);
     494    TRACE("dataMin = %lg dataMax = %lg nzero_min = %lg",
    495495          vmin, vmax, nzero_min);
    496496
     
    521521    if (volPtr) {
    522522        volPtr->location(Vector3(dx0, dy0, dz0));
    523         TRACE("Set volume location to %g %g %g\n", dx0, dy0, dz0);
     523        TRACE("Set volume location to %g %g %g", dx0, dy0, dz0);
    524524    }
    525525    return volPtr;
  • trunk/packages/vizservers/nanovis/nanovis.cpp

    r3408 r3452  
    189189const float def_eye_z = 2.5f;
    190190
    191 #ifndef XINETD
    192 // Variables for mouse events
    193 // Last locations mouse events
    194 static int left_last_x;
    195 static int left_last_y;
    196 static int right_last_x;
    197 static int right_last_y;
    198 static bool left_down = false;
    199 static bool right_down = false;
    200 #endif /*XINETD*/
    201 
    202191// Image based flow visualization slice location
    203192// FLOW
     
    208197NanoVis::removeAllData()
    209198{
    210     TRACE("in removeAllData\n");
     199    TRACE("Enter");
    211200    if (grid != NULL) {
    212201        TRACE("Deleting grid");
     
    278267    }
    279268#endif
     269    TRACE("Leave");
    280270}
    281271
     
    480470doExit(int code)
    481471{
    482     TRACE("in doExit: %d\n", code);
     472    TRACE("in doExit: %d", code);
    483473    NanoVis::removeAllData();
    484474
     
    489479#endif
    490480
    491 #ifdef XINETD
    492481    NvExitService();
    493 #endif
    494482
    495483#ifdef KEEPSTATS
     
    507495    int result;
    508496
    509     TRACE("command: '%s'", Tcl_DStringValue(dsPtr));
     497#ifdef WANT_TRACE
     498    char *str = Tcl_DStringValue(dsPtr);
     499    std::string cmd(str);
     500    cmd.erase(cmd.find_last_not_of(" \n\r\t")+1);
     501    TRACE("command %lu: '%s'", stats.nCommands+1, cmd.c_str());
     502#endif
    510503
    511504    gettimeofday(&tv, NULL);
     
    524517    stats.cmdTime += finish - start;
    525518    stats.nCommands++;
    526     TRACE("leaving executeCommand status=%d\n", result);
     519    TRACE("leaving executeCommand status=%d", result);
    527520    return result;
    528521}
     
    533526    /* Move the camera and its target by equal amounts along the x and y
    534527     * axes. */
    535     TRACE("pan: x=%f, y=%f\n", dx, dy);
     528    TRACE("pan: x=%f, y=%f", dx, dy);
    536529
    537530    cam->x(def_eye_x - dx);
    538531    cam->y(def_eye_y + dy);
    539     TRACE("set eye to %f %f\n", cam->x(), cam->y());
     532    TRACE("set eye to %f %f", cam->x(), cam->y());
    540533}
    541534
     
    545538    /* Move the camera and its target by equal amounts along the x and y
    546539     * axes. */
    547     TRACE("zoom: z=%f\n", z);
     540    TRACE("zoom: z=%f", z);
    548541
    549542    cam->z(def_eye_z / z);
    550     TRACE("set cam z to %f\n", cam->z());
     543    TRACE("set cam z to %f", cam->z());
    551544}
    552545
     
    628621                      int width, int height, const char *volArg)
    629622{
    630     TRACE("in renderLegend\n");
     623    TRACE("Enter");
    631624
    632625    int old_width = winWidth;
     
    668661    delete legendTexture;
    669662    legendTexture = NULL;
    670     TRACE("leaving renderLegend\n");
     663    TRACE("Leave");
    671664    return TCL_OK;
    672665}
     
    676669NanoVis::initOffscreenBuffer()
    677670{
    678     TRACE("in initOffscreenBuffer\n");
     671    TRACE("Enter");
    679672    assert(_finalFbo == 0);
    680673    // Initialize a fbo for final display.
     
    715708    }
    716709
    717     TRACE("leaving initOffscreenBuffer\n");
     710    TRACE("Leave");
    718711}
    719712
     
    722715NanoVis::resizeOffscreenBuffer(int w, int h)
    723716{
    724     TRACE("in resizeOffscreenBuffer(%d, %d)\n", w, h);
     717    TRACE("Enter (%d, %d)", w, h);
    725718    if ((w == winWidth) && (h == winHeight)) {
    726719        return;
     
    732725        fonts->resize(w, h);
    733726    }
    734     TRACE("screenBuffer size: %d %d\n", w, h);
     727    TRACE("screenBuffer size: %d %d", w, h);
    735728
    736729    if (screenBuffer != NULL) {
     
    747740    glDeleteRenderbuffersEXT(1, &_finalDepthRb);
    748741
    749     TRACE("before deleteframebuffers\n");
     742    TRACE("before deleteframebuffers");
    750743    glDeleteFramebuffersEXT(1, &_finalFbo);
    751744
    752     TRACE("reinitialize FBO\n");
     745    TRACE("reinitialize FBO");
    753746    //Reinitialize final fbo for final display
    754747    glGenFramebuffersEXT(1, &_finalFbo);
     
    788781    }
    789782
    790     TRACE("change camera\n");
     783    TRACE("change camera");
    791784    //change the camera setting
    792785    cam->setScreenSize(0, 0, winWidth, winHeight);
    793786    planeRenderer->setScreenSize(winWidth, winHeight);
    794787
    795     TRACE("leaving resizeOffscreenBuffer(%d, %d)\n", w, h);
     788    TRACE("Leave (%d, %d)", w, h);
    796789}
    797790
     
    800793{
    801794    if (!NvShader::printErrorInfo()) {
    802         TRACE("Cg error, exiting...\n");
     795        TRACE("Cg error, exiting...");
    803796        doExit(-1);
    804797    }
     
    808801{
    809802    // print OpenGL driver information
    810     TRACE("-----------------------------------------------------------\n");
    811     TRACE("OpenGL version: %s\n", glGetString(GL_VERSION));
    812     TRACE("OpenGL vendor: %s\n", glGetString(GL_VENDOR));
    813     TRACE("OpenGL renderer: %s\n", glGetString(GL_RENDERER));
    814     TRACE("-----------------------------------------------------------\n");
     803    TRACE("-----------------------------------------------------------");
     804    TRACE("OpenGL version: %s", glGetString(GL_VERSION));
     805    TRACE("OpenGL vendor: %s", glGetString(GL_VENDOR));
     806    TRACE("OpenGL renderer: %s", glGetString(GL_RENDERER));
     807    TRACE("-----------------------------------------------------------");
    815808
    816809    if (path == NULL) {
    817         ERROR("No path defined for shaders or resources\n");
     810        ERROR("No path defined for shaders or resources");
    818811        doExit(1);
    819812    }
    820813    GLenum err = glewInit();
    821814    if (GLEW_OK != err) {
    822         ERROR("Can't init GLEW: %s\n", glewGetErrorString(err));
     815        ERROR("Can't init GLEW: %s", glewGetErrorString(err));
    823816        doExit(1);
    824817    }
    825     TRACE("Using GLEW %s\n", glewGetString(GLEW_VERSION));
     818    TRACE("Using GLEW %s", glewGetString(GLEW_VERSION));
    826819
    827820    // OpenGL 2.1 includes VBOs, PBOs, MRT, NPOT textures, point parameters, point sprites,
    828821    // GLSL 1.2, and occlusion queries.
    829822    if (!GLEW_VERSION_2_1) {
    830         ERROR("OpenGL version 2.1 or greater is required\n");
     823        ERROR("OpenGL version 2.1 or greater is required");
    831824        doExit(1);
    832825    }
     
    835828    // indirect GLX contexts
    836829    if (!GLEW_ARB_pixel_buffer_object) {
    837         ERROR("Pixel buffer objects are not supported by driver, please check that the user running nanovis has permissions to create a direct rendering context (e.g. user has read/write access to /dev/nvidia* device nodes in Linux).\n");
     830        ERROR("Pixel buffer objects are not supported by driver, please check that the user running nanovis has permissions to create a direct rendering context (e.g. user has read/write access to /dev/nvidia* device nodes in Linux).");
    838831        doExit(1);
    839832    }
     
    843836    // Framebuffer objects were promoted in 3.0
    844837    if (!GLEW_EXT_framebuffer_object) {
    845         ERROR("EXT_framebuffer_oject extension is required\n");
     838        ERROR("EXT_framebuffer_oject extension is required");
    846839        doExit(1);
    847840    }
     
    849842    // FIXME: can use NPOT in place of rectangle textures
    850843    if (!GLEW_ARB_texture_rectangle) {
    851         ERROR("ARB_texture_rectangle extension is required\n");
     844        ERROR("ARB_texture_rectangle extension is required");
    852845        doExit(1);
    853846    }
     
    856849    if (!GLEW_ARB_texture_float ||
    857850        !GLEW_ARB_color_buffer_float) {
    858         ERROR("ARB_texture_float and ARB_color_buffer_float extensions are required\n");
     851        ERROR("ARB_texture_float and ARB_color_buffer_float extensions are required");
    859852        doExit(1);
    860853    }
     
    863856    if (!GLEW_NV_vertex_program3 ||
    864857        !GLEW_NV_fragment_program2) {
    865         ERROR("NV_vertex_program3 and NV_fragment_program2 extensions are required\n");
     858        ERROR("NV_vertex_program3 and NV_fragment_program2 extensions are required");
    866859        doExit(1);
    867860    }
    868861
    869862    if (!R2FilePath::getInstance()->setPath(path)) {
    870         ERROR("can't set file path to %s\n", path);
     863        ERROR("can't set file path to %s", path);
    871864        doExit(1);
    872865    }
     
    901894NanoVis::initGL()
    902895{
    903     TRACE("in initGL\n");
     896    TRACE("in initGL");
    904897    //buffer to store data read from the screen
    905898    if (screenBuffer) {
     
    955948    //assert(glGetError()==0);
    956949
    957     TRACE("leaving initGL\n");
     950    TRACE("leaving initGL");
    958951}
    959952
     
    10881081            sprintf(filename, "/tmp/flow_animation/image%03d.bmp", frame_number);
    10891082
    1090         TRACE("Writing %s\n", filename);
     1083        TRACE("Writing %s", filename);
    10911084        f = fopen(filename, "wb");
    10921085        if (f == 0) {
    1093             ERROR("cannot create file\n");
     1086            ERROR("cannot create file");
    10941087        }
    10951088    } else {
    10961089        f = fopen("/tmp/image.bmp", "wb");
    10971090        if (f == 0) {
    1098             ERROR("cannot create file\n");
     1091            ERROR("cannot create file");
    10991092        }
    11001093    }
    11011094    if (fwrite(header, SIZEOF_BMP_HEADER, 1, f) != 1) {
    1102         ERROR("can't write header: short write\n");
     1095        ERROR("can't write header: short write");
    11031096    }
    11041097    if (fwrite(screenBuffer, (3*winWidth+pad)*winHeight, 1, f) != 1) {
    1105         ERROR("can't write data: short write\n");
     1098        ERROR("can't write data: short write");
    11061099    }
    11071100    fclose(f);
     
    12111204    char header[200];
    12121205
    1213     TRACE("Enter ppmWrite (%dx%d)\n", winWidth, winHeight);
     1206    TRACE("Enter (%dx%d)", winWidth, winHeight);
    12141207    // Generate the PPM binary file header
    12151208    sprintf(header, "P6 %d %d %d\n", winWidth, winHeight, PPM_MAXVAL);
     
    12461239    }
    12471240    if (writev(1, iov, nRecs) < 0) {
    1248         ERROR("write failed: %s\n", strerror(errno));
     1241        ERROR("write failed: %s", strerror(errno));
    12491242    }
    12501243    free(iov);
    12511244    stats.nFrames++;
    12521245    stats.nBytes += (bytesPerRow * winHeight);
    1253     TRACE("Leaving ppmWrite (%dx%d)\n", winWidth, winHeight);
     1246    TRACE("Leave (%dx%d)", winWidth, winHeight);
    12541247}
    12551248
     
    12881281    iov[1].iov_len = dlen;
    12891282    if (writev(1, iov, nRecs) < 0) {
    1290         ERROR("write failed: %s\n", strerror(errno));
     1283        ERROR("write failed: %s", strerror(errno));
    12911284    }
    12921285    delete [] iov;
     
    12981291NanoVis::idle()
    12991292{
    1300     TRACE("in idle()\n");
     1293    TRACE("Enter");
     1294
    13011295    glutSetWindow(renderWindow);
    13021296
    1303 #ifdef XINETD
    1304     xinetdListen();
    1305 #else
    1306     glutPostRedisplay();
    1307 #endif
    1308     TRACE("leaving idle()\n");
    1309 }
    1310 
    1311 void
    1312 NanoVis::displayOffscreenBuffer()
    1313 {
    1314     TRACE("in display_offscreen_buffer\n");
    1315 
    1316     glEnable(GL_TEXTURE_2D);
    1317     glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
    1318     glBindTexture(GL_TEXTURE_2D, _finalColorTex);
    1319 
    1320     glViewport(0, 0, winWidth, winHeight);
    1321     glMatrixMode(GL_PROJECTION);
    1322     glLoadIdentity();
    1323     gluOrtho2D(0, winWidth, 0, winHeight);
    1324     glMatrixMode(GL_MODELVIEW);
    1325     glLoadIdentity();
    1326 
    1327     glColor3f(1.,1.,1.);                //MUST HAVE THIS LINE!!!
    1328     glBegin(GL_QUADS);
    1329     {
    1330         glTexCoord2f(0, 0); glVertex2f(0, 0);
    1331         glTexCoord2f(1, 0); glVertex2f(winWidth, 0);
    1332         glTexCoord2f(1, 1); glVertex2f(winWidth, winHeight);
    1333         glTexCoord2f(0, 1); glVertex2f(0, winHeight);
    1334     }
    1335     glEnd();
    1336 
    1337     TRACE("leaving display_offscreen_buffer\n");
     1297    processCommands();
     1298
     1299    TRACE("Leave");
    13381300}
    13391301
     
    14351397            volInterp->getStartTime();
    14361398
    1437         TRACE("%lf %lf\n", elapsed_time,
     1399        TRACE("%lf %lf", elapsed_time,
    14381400              volInterp->getInterval());
    14391401        float fraction;
     
    14461408            fraction = f / volInterp->getInterval();
    14471409        }
    1448         TRACE("fraction : %f\n", fraction);
     1410        TRACE("fraction : %f", fraction);
    14491411        volInterp->update(fraction);
    14501412    }
     
    14561418    double xMin, xMax, yMin, yMax, zMin, zMax, wMin, wMax;
    14571419
    1458     TRACE("in SetVolumeRanges\n");
     1420    TRACE("in SetVolumeRanges");
    14591421    xMin = yMin = zMin = wMin = DBL_MAX;
    14601422    xMax = yMax = zMax = wMax = -DBL_MAX;
     
    15031465    }
    15041466    Volume::updatePending = false;
    1505     TRACE("leaving SetVolumeRanges\n");
     1467    TRACE("leaving SetVolumeRanges");
    15061468}
    15071469
     
    15111473    double xMin, xMax, yMin, yMax, zMin, zMax, wMin, wMax;
    15121474
    1513     TRACE("in setHeightmapRanges\n");
     1475    TRACE("in setHeightmapRanges");
    15141476    xMin = yMin = zMin = wMin = DBL_MAX;
    15151477    xMax = yMax = zMax = wMax = -DBL_MAX;
     
    15641526    }
    15651527    HeightMap::updatePending = false;
    1566     TRACE("leaving setHeightmapRanges\n");
     1528    TRACE("leaving setHeightmapRanges");
    15671529}
    15681530
     
    15701532NanoVis::display()
    15711533{
    1572     TRACE("in display\n");
     1534    TRACE("Enter");
     1535
    15731536    if (flags & MAP_FLOWS) {
    15741537#ifdef notdef
     
    15941557    bindOffscreenBuffer();
    15951558
    1596     TRACE("in display: glClear\n");
     1559    TRACE("glClear");
    15971560    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //clear screen
    15981561
    15991562    if (volumeMode) {
    1600         TRACE("in display: volumeMode\n");
     1563        TRACE("volumeMode");
    16011564        //3D rendering mode
    16021565        glEnable(GL_DEPTH_TEST);
     
    16591622
    16601623        if (heightmapTable.numEntries > 0) {
    1661             TRACE("in display: render heightmap\n");
     1624            TRACE("render heightmap");
    16621625            Tcl_HashEntry *hPtr;
    16631626            Tcl_HashSearch iter;
     
    16811644    perf->reset();
    16821645    CHECK_FRAMEBUFFER_STATUS();
    1683     TRACE("leaving display\n");
    1684 }
    1685 
    1686 #ifndef XINETD
     1646    TRACE("Leave");
     1647}
     1648
    16871649void
    1688 NanoVis::mouse(int button, int state, int x, int y)
    1689 {
    1690     if (button == GLUT_LEFT_BUTTON) {
    1691         if (state == GLUT_DOWN) {
    1692             left_last_x = x;
    1693             left_last_y = y;
    1694             left_down = true;
    1695             right_down = false;
    1696         } else {
    1697             left_down = false;
    1698             right_down = false;
    1699         }
    1700     } else {
    1701         //TRACE("right mouse\n");
    1702 
    1703         if (state == GLUT_DOWN) {
    1704             //TRACE("right mouse down\n");
    1705             right_last_x = x;
    1706             right_last_y = y;
    1707             left_down = false;
    1708             right_down = true;
    1709         } else {
    1710             //TRACE("right mouse up\n");
    1711             left_down = false;
    1712             right_down = false;
    1713         }
    1714     }
    1715 }
    1716 
    1717 void
    1718 NanoVis::updateRot(int delta_x, int delta_y)
    1719 {
    1720     Vector3 angle;
    1721 
    1722     angle = cam->rotate();
    1723     angle.x += delta_x;
    1724     angle.y += delta_y;
    1725 
    1726     if (angle.x > 360.0) {
    1727         angle.x -= 360.0;
    1728     } else if(angle.x < -360.0) {
    1729         angle.x += 360.0;
    1730     }
    1731     if (angle.y > 360.0) {
    1732         angle.y -= 360.0;
    1733     } else if(angle.y < -360.0) {
    1734         angle.y += 360.0;
    1735     }
    1736     cam->rotate(angle);
    1737 }
    1738 
    1739 void
    1740 NanoVis::updateTrans(int delta_x, int delta_y, int delta_z)
    1741 {
    1742     cam->x(cam->x() + delta_x * 0.03);
    1743     cam->y(cam->y() + delta_y * 0.03);
    1744     cam->z(cam->z() + delta_z * 0.03);
    1745 }
    1746 
    1747 void
    1748 NanoVis::keyboard(unsigned char key, int x, int y)
    1749 {
    1750 #ifdef EVENTLOG
    1751     if (log) {
    1752         float param[3];
    1753         param[0] = cam->x();
    1754         param[1] = cam->y();
    1755         param[2] = cam->z();
    1756         Event* tmp = new Event(EVENT_MOVE, param, NvGetTimeInterval());
    1757         tmp->write(event_log);
    1758         delete tmp;
    1759     }
    1760 #endif
    1761 
    1762     switch (key) {
    1763     case 'a': {
    1764         TRACE("flowvis activated\n");
    1765         char cmd[] = {
    1766             "foreach flow [flow names] {\n"
    1767             "    $flow configure -hide no -slice yes\n"
    1768             "}\n"
    1769         };
    1770         Tcl_Eval(interp, cmd);
    1771     }
    1772         break;
    1773     case 'd': {
    1774         TRACE("flowvis deactivated\n");
    1775         char cmd[] = {
    1776             "foreach flow [flow names] {\n"
    1777             "    $flow configure -hide yes -slice no\n"
    1778             "}\n"
    1779         };
    1780         Tcl_Eval(interp, cmd);
    1781     }
    1782         break;
    1783     case 'r': {
    1784         TRACE("flowvis reset\n");
    1785         char cmd[] = {
    1786             "flow reset\n"
    1787         };
    1788         Tcl_Eval(interp, cmd);
    1789     }
    1790         break;
    1791     }
    1792 }
    1793 
    1794 void
    1795 NanoVis::motion(int x, int y)
    1796 {
    1797     int old_x, old_y;
    1798 
    1799     if (left_down) {
    1800         old_x = left_last_x;
    1801         old_y = left_last_y;
    1802     } else if (right_down) {
    1803         old_x = right_last_x;
    1804         old_y = right_last_y;
    1805     }
    1806 
    1807     int delta_x = x - old_x;
    1808     int delta_y = y - old_y;
    1809 
    1810     //more coarse event handling
    1811     //if(abs(delta_x)<10 && abs(delta_y)<10)
    1812     //return;
    1813 
    1814     if (left_down) {
    1815         left_last_x = x;
    1816         left_last_y = y;
    1817 
    1818         updateRot(-delta_y, -delta_x);
    1819     } else if (right_down) {
    1820         //TRACE("right mouse motion (%d,%d)\n", x, y);
    1821 
    1822         right_last_x = x;
    1823         right_last_y = y;
    1824 
    1825         updateTrans(0, 0, delta_x);
    1826     }
    1827 
    1828 #ifdef EVENTLOG
    1829     Vector3 angle = cam->rotate();
    1830     Event* tmp = new Event(EVENT_ROTATE, &angle, NvGetTimeInterval());
    1831     tmp->write(event_log);
    1832     delete tmp;
    1833 #endif
    1834     glutPostRedisplay();
    1835 }
    1836 
    1837 void
    1838 NanoVis::render()
    1839 {
    1840     if (licRenderer != NULL) {
    1841         licRenderer->convolve();
    1842     }
    1843 
    1844 #ifdef notdef
    1845     if ((flowVisRenderer != NULL) && (flowVisRenderer->active())) {
    1846         flowVisRenderer->advect();
    1847     }
    1848 #endif
    1849     update();
    1850     display();
    1851     glutSwapBuffers();
    1852 }
    1853 
    1854 void
    1855 NanoVis::resize(int x, int y)
    1856 {
    1857     glViewport(0, 0, x, y);
    1858 }
    1859 
    1860 #endif /*XINETD*/
    1861 
    1862 void
    1863 NanoVis::xinetdListen()
     1650NanoVis::processCommands()
    18641651{
    18651652    flags &= ~REDRAW_PENDING;
    18661653
    1867     TRACE("Enter xinetdListen\n");
     1654    TRACE("Enter");
    18681655
    18691656    int flags = fcntl(0, F_GETFL, 0);
     
    18871674        //  here.
    18881675        //
    1889         TRACE("in xinetdListen: EOF=%d\n", feof(NanoVis::stdin));
     1676        TRACE("EOF=%d", feof(NanoVis::stdin));
    18901677        while (!feof(NanoVis::stdin)) {
    18911678            int c = fgetc(NanoVis::stdin);
     
    19401727            iov[1].iov_len = msgSize;
    19411728            if (writev(1, iov, 2) < 0) {
    1942                 ERROR("write failed: %s\n", strerror(errno));
     1729                ERROR("write failed: %s", strerror(errno));
    19431730            }
    19441731        }
    1945         TRACE("Leaving xinetd_listen on ERROR\n");
     1732        TRACE("Leaving on ERROR");
    19461733        return;
    19471734    }
     
    19561743    display();
    19571744
    1958 #ifdef XINETD
    19591745    readScreen();
    1960 #else
    1961     displayOffscreenBuffer(); //display the final rendering on screen
    1962     readScreen();
    1963     glutSwapBuffers();
    1964 #endif
    19651746
    19661747    if (feof(NanoVis::stdin)) {
     
    19681749    }
    19691750#ifdef DO_RLE
    1970     do_rle();
     1751    doRle();
    19711752    int sizes[2] = {  offsets_size*sizeof(offsets[0]), rle_size };
    1972     TRACE("Writing %d,%d\n", sizes[0], sizes[1]);
     1753    TRACE("Writing %d,%d", sizes[0], sizes[1]);
    19731754    write(1, &sizes, sizeof(sizes));
    19741755    write(1, offsets, offsets_size*sizeof(offsets[0]));
     
    19771758    ppmWrite("nv>image -type image -bytes");
    19781759#endif
    1979     TRACE("Leaving xinetd_listen OK\n");
     1760    TRACE("Leave");
    19801761}
    19811762
     
    20061787    glutIdleFunc(NanoVis::idle);
    20071788
    2008 #ifndef XINETD
    2009     glutMouseFunc(NanoVis::mouse);
    2010     glutMotionFunc(NanoVis::motion);
    2011     glutKeyboardFunc(NanoVis::keyboard);
    2012     glutReshapeFunc(NanoVis::resize);
    2013     glutDisplayFunc(NanoVis::render);
    2014 #else
    20151789    glutDisplayFunc(NanoVis::display);
    20161790    glutReshapeFunc(NanoVis::resizeOffscreenBuffer);
    2017 #endif
    20181791
    20191792    while (1) {
     
    20851858        // See if we can derive the path from the location of the program.
    20861859        // Assume program is in the form <path>/bin/nanovis.
    2087 
    2088 #ifdef XINETD
    20891860        path = argv[0];
    20901861        p = strrchr((char *)path, '/');
     
    20941865        }
    20951866        if (p == NULL) {
    2096             TRACE("path not specified\n");
     1867            TRACE("path not specified");
    20971868            return 1;
    20981869        }
     
    21011872        sprintf(newPath, "%s/lib/shaders:%s/lib/resources", path, path);
    21021873        path = newPath;
    2103 #else
    2104         char buff[256];
    2105         getcwd(buff, 255);
    2106         p = strrchr(buff, '/');
    2107         if (p != NULL) {
    2108             *p = '\0';
    2109         }
    2110         newPath = new char[(strlen(buff) + 15) * 2 + 1];
    2111         sprintf(newPath, "%s/lib/shaders:%s/lib/resources", buff, buff);
    2112         path = newPath;
    2113 #endif
    21141874    }
    21151875
    21161876    R2FilePath::getInstance()->setWorkingDirectory(argc, (const char**) argv);
    21171877
    2118 #ifdef XINETD
    21191878#ifdef notdef
    21201879    signal(SIGPIPE, SIG_IGN);
    21211880#endif
    21221881    NvInitService();
    2123 #endif
    21241882
    21251883    NanoVis::init(path);
  • trunk/packages/vizservers/nanovis/nanovis.h

    r3377 r3452  
    7272    };
    7373
    74     static void xinetdListen();
     74    static void processCommands();
    7575    static void init(const char *path);
    7676    static void initGL();
    7777    static void initOffscreenBuffer();
    7878    static void resizeOffscreenBuffer(int w, int h);
    79     static void displayOffscreenBuffer();
    8079    static void display();
    8180    static void draw3dAxis();
     
    118117
    119118    static void removeVolume(Volume *volPtr);
    120 
    121 #ifndef XINETD
    122     static void keyboard(unsigned char key, int x, int y);
    123     static void mouse(int button, int state, int x, int y);
    124     static void motion(int x, int y);
    125     static void updateRot(int delta_x, int delta_y);
    126     static void updateTrans(int delta_x, int delta_y, int delta_z);
    127     static void resize(int w, int h);
    128     static void render();
    129 #endif
    130119
    131120    static void readScreen()
Note: See TracChangeset for help on using the changeset viewer.