Commit fb5dcb09 authored by Ben Boeckel's avatar Ben Boeckel Committed by Kitware Robot
Browse files

Merge topic 'remove-gmv-reader'

1b316632

 GMV: remove reader
Acked-by: Kitware Robot's avatarKitware Robot <kwrobot@kitware.com>
Merge-request: !32
parents 51d68c40 1b316632
......@@ -90,22 +90,6 @@ endforeach(db)
add_definitions("-DRC_CPP_VISIT_BUILD")
#-----------------------------------------------------------------------------
# GMV Reader needs OpenGLU library. So check if it exists before enabling the
# GMV reader.
include(vtkOpenGL)
set (__gmv_default_status OFF)
if (OPENGL_GLU_FOUND)
# BUG #13489. There are cases in FindOpenGL.cmake when OPENGL_GLU_FOUND is not
# set at all. Hence, don't use ${OPENGL_GLU_FOUND} directly.
set (__gmv_default_status ON)
endif()
visit_include_reader_source(GMV ${__gmv_default_status})
if (VISIT_BUILD_READER_GMV AND NOT OPENGL_GLU_FOUND)
message(FATAL_ERROR "Unable to locate GLU library required for GMV reader.")
endif()
#-----------------------------------------------------------------------------
visit_include_reader_source(Silo OFF)
if(VISIT_BUILD_READER_Silo)
......@@ -149,7 +133,6 @@ endif(VISIT_BUILD_READER_Mili)
#the visit files
include_directories(BEFORE
${VISIT_DB_INC_DIRS}
${CMAKE_CURRENT_SOURCE_DIR}/Common
)
include_directories(
......@@ -212,7 +195,3 @@ endif(Boxlib_FOUND AND VISIT_BUILD_READER_Boxlib3D)
if(HAVE_LIBMILI AND VISIT_BUILD_READER_Mili)
target_link_libraries(vtkIOVisItBridge LINK_PRIVATE ${Mili_LIBRARIES})
endif(HAVE_LIBMILI AND VISIT_BUILD_READER_Mili)
if (VISIT_BUILD_READER_GMV)
vtk_opengl_link(vtkIOVisItBridge)
endif()
/*****************************************************************************
*
* Copyright (c) 2000 - 2012, Lawrence Livermore National Security, LLC
* Produced at the Lawrence Livermore National Laboratory
* LLNL-CODE-442911
* All rights reserved.
*
* This file is part of VisIt. For details, see https://visit.llnl.gov/. The
* full copyright notice is contained in the file COPYRIGHT located at the root
* of the VisIt distribution or at http://www.llnl.gov/visit/copyright.html.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice,
* this list of conditions and the disclaimer below.
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the disclaimer (as noted below) in the
* documentation and/or other materials provided with the distribution.
* - Neither the name of the LLNS/LLNL nor the names of its contributors may
* be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL LAWRENCE LIVERMORE NATIONAL SECURITY,
* LLC, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
* DAMAGE.
*
*****************************************************************************/
#include <MaterialEncoder.h>
#include <avtMaterial.h>
//
// Template function for memory reallocation.
//
template <class T>
T *remake(T *ptr, int oldsize, int size)
{
T *retval = new T[size];
T *iptr = retval;
for(int i = 0; i < oldsize; ++i)
*iptr++ = ptr[i];
delete [] ptr;
return retval;
}
// ****************************************************************************
// Method: MaterialEncoder::MaterialEncoder
//
// Purpose:
// Constructor
//
// Programmer: Brad Whitlock
// Creation: Wed Aug 6 11:33:52 PDT 2003
//
// Modifications:
//
// ****************************************************************************
MaterialEncoder::MaterialEncoder() : matNames()
{
have_mixed = false;
mix_zone = NULL;
mix_mat = NULL;
mix_vf = NULL;
mix_next = NULL;
matlist = NULL;
// initialize private members.
_array_size = 0;
_array_index = 1;
_array_growth = 5000;
}
// ****************************************************************************
// Method: MaterialEncoder::~MaterialEncoder
//
// Purpose:
// Destructor.
//
// Programmer: Brad Whitlock
// Creation: Wed Aug 6 11:34:04 PDT 2003
//
// Modifications:
//
// ****************************************************************************
MaterialEncoder::~MaterialEncoder()
{
delete [] matlist;
if (have_mixed)
{
delete [] mix_zone;
delete [] mix_mat;
delete [] mix_vf;
delete [] mix_next;
}
}
// ****************************************************************************
// Method: MaterialEncoder::AddMaterial
//
// Purpose:
// Adds a material to the list of materials.
//
// Arguments:
// mat : The name of a material.
//
// Programmer: Brad Whitlock
// Creation: Wed Aug 6 11:34:20 PDT 2003
//
// Modifications:
//
// ****************************************************************************
void
MaterialEncoder::AddMaterial(const std::string &mat)
{
matNames.push_back(mat);
}
// ****************************************************************************
// Method: MaterialEncoder::AddClean
//
// Purpose:
// Adds a clean zone for the specified zone.
//
// Arguments:
// zoneId : The zone number that we're calling clean.
// matNumber : The material number we're putting into the zone.
//
// Programmer: Brad Whitlock
// Creation: Wed Aug 6 11:34:44 PDT 2003
//
// Modifications:
//
// ****************************************************************************
void
MaterialEncoder::AddClean(int zoneId, int matNumber)
{
matlist[zoneId] = matNumber;
}
// ****************************************************************************
// Method: MaterialEncoder::AddMixed
//
// Purpose:
// Adds a mixed zone for the specified zone.
//
// Arguments:
// zoneId : The zone number that we're calling mixed.
// matNumbers : The material numbers present in the zone.
// matVf : The material volume fractions in the zone.
// nMats : The number of materials in the zone.
//
// Programmer: Brad Whitlock
// Creation: Wed Aug 6 11:37:37 PDT 2003
//
// Modifications:
// Brad Whitlock, Tue Dec 7 16:16:19 PST 2004
// Converted matVf from double to float.
//
// ****************************************************************************
void
MaterialEncoder::AddMixed(int zoneId, const int *matNumbers,
const float *matVf, int nMats)
{
int i;
// Grow the arrays if they will not fit nMats materials.
Resize(nMats);
// Record the mixed zone as a negative offset into the mix arrays.
matlist[zoneId] = -_array_index;
// Update the mix arrays.
for(i = 0; i < nMats; ++i)
{
int index = _array_index - 1;
mix_zone[index] = zoneId;
mix_mat[index] = matNumbers[i];
mix_vf[index] = matVf[i];
if(i < nMats - 1)
mix_next[index] = index + 2;
else
mix_next[index] = 0;
++(_array_index);
}
// indicate that we have mixed materials.
have_mixed = true;
}
// ****************************************************************************
// Method: MaterialEncoder::AllocClean
//
// Purpose:
// Allocates clean zones.
//
// Arguments:
// nZones : The number of clean zones to allocate.
//
// Programmer: Brad Whitlock
// Creation: Wed Aug 6 11:38:58 PDT 2003
//
// Modifications:
//
// ****************************************************************************
void
MaterialEncoder::AllocClean(int nZones)
{
matlist = new int[nZones];
}
// ****************************************************************************
// Method: MaterialEncoder::GetMixedSize
//
// Purpose:
// Returns the size of the mixed arrays.
//
// Returns: The size of the mixed arrays.
//
// Programmer: Brad Whitlock
// Creation: Wed Aug 6 11:39:25 PDT 2003
//
// Modifications:
// Eric Brugger, Tue Mar 16 16:33:08 PST 2004
// Modified it to return the correct size, which is one less than the
// next index to insert an entry.
//
// ****************************************************************************
int
MaterialEncoder::GetMixedSize() const
{
return _array_index - 1;
}
// ****************************************************************************
// Method: MaterialEncoder::CreateMaterial
//
// Purpose:
// Creates an avtMaterial from the material information in the object.
//
// Arguments:
// dims : The dimensions of the mesh associated with the material.
// ndims : The number of dimensions.
//
// Returns: An avtMaterial object that contains the material arrays.
//
// Programmer: Brad Whitlock
// Creation: Wed Aug 6 11:39:57 PDT 2003
//
// Modifications:
// Brad Whitlock, Wed Sep 8 14:52:13 PST 2004
// I added support for material names back in.
//
// ****************************************************************************
avtMaterial *
MaterialEncoder::CreateMaterial(const int *dims, int ndims) const
{
int *matnos = new int[matNames.size()];
char **names = new char *[matNames.size()];
for(unsigned int i = 0; i < matNames.size(); ++i)
{
matnos[i] = i + 1;
names[i] = (char *)matNames[i].c_str();
}
avtMaterial *retval;
if(have_mixed)
{
retval = new avtMaterial(
matNames.size(),
matnos,
names,
ndims,
dims,
0,
matlist,
GetMixedSize(),
mix_mat,
mix_next,
mix_zone,
mix_vf
);
}
else
{
retval = new avtMaterial(
matNames.size(),
matnos,
names,
ndims,
dims,
0,
matlist,
0,
0,
0,
0,
0
);
}
delete [] matnos;
delete [] names;
return retval;
}
// ****************************************************************************
// Method: MaterialEncoder::Resize
//
// Purpose:
// Resizes the mixed material arrays so they can hold more information.
//
// Programmer: Brad Whitlock
// Creation: Wed Aug 6 11:41:07 PDT 2003
//
// Modifications:
//
// ****************************************************************************
void
MaterialEncoder::Resize(int nMats)
{
if(_array_index + nMats >= _array_size)
{
int new_size = _array_size + _array_growth;
if(_array_size == 0)
{
// Reallocate arrays in large increments.
mix_zone = new int[new_size];
mix_mat = new int[new_size];
mix_vf = new float[new_size];
mix_next = new int[new_size];
}
else
{
// Reallocate arrays in large increments.
mix_zone = remake(mix_zone, _array_size, new_size);
mix_mat = remake(mix_mat, _array_size, new_size);
mix_vf = remake(mix_vf, _array_size, new_size);
mix_next = remake(mix_next, _array_size, new_size);
}
_array_size = new_size;
}
}
/*****************************************************************************
*
* Copyright (c) 2000 - 2012, Lawrence Livermore National Security, LLC
* Produced at the Lawrence Livermore National Laboratory
* LLNL-CODE-442911
* All rights reserved.
*
* This file is part of VisIt. For details, see https://visit.llnl.gov/. The
* full copyright notice is contained in the file COPYRIGHT located at the root
* of the VisIt distribution or at http://www.llnl.gov/visit/copyright.html.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice,
* this list of conditions and the disclaimer below.
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the disclaimer (as noted below) in the
* documentation and/or other materials provided with the distribution.
* - Neither the name of the LLNS/LLNL nor the names of its contributors may
* be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL LAWRENCE LIVERMORE NATIONAL SECURITY,
* LLC, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
* DAMAGE.
*
*****************************************************************************/
#ifndef MATERIAL_ENCODER_H
#define MATERIAL_ENCODER_H
#include <string>
#include <vector>
class avtMaterial;
// ****************************************************************************
// Class: MaterialEncoder
//
// Purpose:
// Keeps track of mixed material information.
//
// Notes:
//
// Programmer: Brad Whitlock
// Creation: Fri Jun 21 13:53:35 PST 2002
//
// Modifications:
// Brad Whitlock, Tue Dec 7 16:15:38 PST 2004
// Changed the double argument to float on the AddMixed method.
//
// ****************************************************************************
class MaterialEncoder
{
public:
MaterialEncoder();
~MaterialEncoder();
void AddMaterial(const std::string &mat);
void AddClean(int zoneId, int matNumber);
void AddMixed(int zoneId, const int *matNumbers, const float *matVf,
int nMats);
void AllocClean(int nZones);
int GetMixedSize() const;
avtMaterial *CreateMaterial(const int *dims, int ndims) const;
private:
void Resize(int nMats);
int have_mixed;
int *mix_zone;
int *mix_mat;
float *mix_vf;
int *mix_next;
int *matlist;
int _array_size;
int _array_index;
int _array_growth;
std::vector<std::string> matNames;
};
#endif
#ifdef _WIN32
#include <windows.h>
#endif
#ifdef __APPLE__
// If we're on Apple then use the mangled Mesa GLU functions since it's
// not readily apparent where else we can find them.
#include <OpenGL/glu.h>
#else
#include <GL/glu.h>
#endif
#include <snprintf.h>
#include <map>
// ****************************************************************************
// Class: VertexManager
//
// Purpose:
// This class manages inserts into a vtkPoints object to make sure that the
// points are unique.
//
// Notes:
//
// Programmer: Brad Whitlock
// Creation: Wed Mar 7 08:58:03 PDT 2007
//
// Modifications:
//
// ****************************************************************************
class VertexManager
{
public:
VertexManager(vtkPoints *pts)
{
points = pts;
}
~VertexManager()
{
}
int GetVertexId(const GLdouble *vert)
{
char keystr[200];
SNPRINTF(keystr, 200, "%12.12e,%12.12e,%12.12e", vert[0], vert[1], vert[2]);
std::string key(keystr);
int ret;
std::map<std::string, int>::const_iterator pos =
vertexNamesToIndex.find(key);
if(pos != vertexNamesToIndex.end())
{
ret = pos->second;
}
else
{
int index = points->GetNumberOfPoints();
points->InsertNextPoint((const double *)vert);
vertexNamesToIndex[key] = index;
ret = index;
}
return ret;
}
private:
vtkPoints *points; // Does not own this pointer.
std::map<std::string, int> vertexNamesToIndex;
};
// ****************************************************************************
// Class: PolygonToTriangles
//
// Purpose:
// This class contains a GLU tessellator object that can convert polygons
// into triangles. This class provides encapsulation and a mechanism for
// the resulting triangles to be read out and used.
//
// Notes:
//
// Programmer: Brad Whitlock
// Creation: Wed Mar 7 08:59:04 PDT 2007
//
// Modifications:
// Eric Brugger, Tue Mar 13 15:50:51 PDT 2007
// Added coding specific to gcc 3.2 to get around a compiler bug.
//
// Kathleen Bonnell, Thu Mar 29 09:01:59 PDT 2007
// Added WIN32 specific code.
//
// Kathleen Bonnell, Mon Oct 1 07:50:46 PDT 2007
// Added SetNormal and ClearTriangles methods.
//
// ****************************************************************************
class PolygonToTriangles
{
public:
PolygonToTriangles(VertexManager *tuv) : vertexAllocs()
{
tessMode = GL_TRIANGLES;
vertexMgr = tuv;
nTrianglesInPolygon = 0;
// Create a tessellator object and set up its callbacks.
tess = gluNewTess();
#if defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ == 2 && __GNUC_PATCHLEVEL__ == 0)
gluTessCallback(tess, GLU_TESS_VERTEX_DATA, (GLvoid (*)(...))vertexCallback);
gluTessCallback(tess, GLU_TESS_BEGIN_DATA, (GLvoid (*)(...))beginCallback);
gluTessCallback(tess, GLU_TESS_END_DATA, (GLvoid (*)(...))endCallback);
gluTessCallback(tess, GLU_TESS_COMBINE_DATA, (GLvoid (*)(...))combineCallback);
#elif defined(_WIN32)
gluTessCallback(tess, GLU_TESS_VERTEX_DATA, (VOID (CALLBACK *)())vertexCallback);
gluTessCallback(tess, GLU_TESS_BEGIN_DATA, (VOID (CALLBACK *)())beginCallback);
gluTessCallback(tess, GLU_TESS_END_DATA, (VOID (CALLBACK *)())endCallback);
gluTessCallback(tess, GLU_TESS_COMBINE_DATA, (VOID (CALLBACK *)())combineCallback);
#else
gluTessCallback(tess, GLU_TESS_VERTEX_DATA, (GLvoid (*)())vertexCallback);
gluTessCallback(tess, GLU_TESS_BEGIN_DATA, (GLvoid (*)())beginCallback);
gluTessCallback(tess, GLU_TESS_END_DATA, (GLvoid (*)())endCallback);