#include <vtkCellArray.h>
#include <vtkIdList.h>
#include <vtkCell.h>
+#include <vtkCellData.h>
#include <vtkInformation.h>
#include <vtkInformationVector.h>
#include <vtkVersion.h>
}
-inline void InsertCell(vtkUnstructuredGrid *theInput,
+inline int InsertCell(vtkUnstructuredGrid *theInput,
vtkCellArray *theConnectivity,
vtkUnsignedCharArray* theCellTypesArray,
vtkIdTypeArray*& theFaces,
vtkCell *aCell = theInput->GetCell(theCellId);
vtkIdList *aPntIds = aCell->GetPointIds();
vtkIdType aNbIds = aPntIds->GetNumberOfIds();
+ vtkIdType aCellId = -1;
theIdList->SetNumberOfIds(aNbIds);
for(vtkIdType i = 0; i < aNbIds; i++){
theIdList->SetId(i,aPntIds->GetId(i));
if (aCellType != VTK_POLYHEDRON)
{
#endif
- theConnectivity->InsertNextCell(theIdList);
+ aCellId = theConnectivity->InsertNextCell(theIdList);
if (theFaceLocations)
theFaceLocations->InsertNextValue(-1);
#if VTK_XVERSION > 50700
}
#endif
- theCellTypesArray->InsertNextValue(aCellType);
+ vtkIdType anID = theCellTypesArray->InsertNextValue(aCellType);
if(theStoreMapping){
theOut2InId.push_back(theCellId);
theIn2OutId[theCellId] = theOutId;
}
+ return aCellId;
}
inline void InsertPointCell(vtkCellArray *theConnectivity,
vtkUnsignedCharArray* aCellTypesArray = vtkUnsignedCharArray::New();
aCellTypesArray->SetNumberOfComponents(1);
aCellTypesArray->Allocate(aNbElems*aCellTypesArray->GetNumberOfComponents());
+ anOutput->GetCellData()->CopyAllocate(anInput->GetCellData(),aNbElems,aNbElems/2);
vtkIdTypeArray *newFaces = 0;
vtkIdTypeArray *newFaceLocations = 0;
if(myChangeMode == eAdding){
for(vtkIdType aCellId = 0, anOutId = 0; aCellId < aNbElems; aCellId++,anOutId++){
if(myCellIds.find(aCellId) != myCellIds.end()){
- InsertCell(anInput,aConnectivity,aCellTypesArray,newFaces,newFaceLocations,aCellId,anIdList,
+ vtkIdType newId = InsertCell(anInput,aConnectivity,aCellTypesArray,newFaces,newFaceLocations,aCellId,anIdList,
myStoreMapping,anOutId,myOut2InId,myIn2OutId);
+ anOutput->GetCellData()->CopyData(anInput->GetCellData(),aCellId,newId);
}
}
}else{
for(vtkIdType aCellId = 0, anOutId = 0; aCellId < aNbElems; aCellId++,anOutId++){
if(myCellIds.find(aCellId) == myCellIds.end()){
- InsertCell(anInput,aConnectivity,aCellTypesArray,newFaces,newFaceLocations,aCellId,anIdList,
+ vtkIdType newId = InsertCell(anInput,aConnectivity,aCellTypesArray,newFaces,newFaceLocations,aCellId,anIdList,
myStoreMapping,anOutId,myOut2InId,myIn2OutId);
+ anOutput->GetCellData()->CopyData(anInput->GetCellData(),aCellId,newId);
}
}
}
for(vtkIdType aCellId = 0, anOutId = 0; aCellId < aNbElems; aCellId++,anOutId++){
vtkIdType aType = anInput->GetCellType(aCellId);
if(myCellTypes.find(aType) != myCellTypes.end()){
- InsertCell(anInput,aConnectivity,aCellTypesArray,newFaces,newFaceLocations,aCellId,anIdList,
+ vtkIdType newId = InsertCell(anInput,aConnectivity,aCellTypesArray,newFaces,newFaceLocations,aCellId,anIdList,
myStoreMapping,anOutId,myOut2InId,myIn2OutId);
+ anOutput->GetCellData()->CopyData(anInput->GetCellData(),aCellId,newId);
}
}
}else{
for(vtkIdType aCellId = 0, anOutId = 0; aCellId < aNbElems; aCellId++,anOutId++){
vtkIdType aType = anInput->GetCellType(aCellId);
if(myCellTypes.find(aType) == myCellTypes.end()){
- InsertCell(anInput,aConnectivity,aCellTypesArray,newFaces,newFaceLocations,aCellId,anIdList,
+ vtkIdType newId = InsertCell(anInput,aConnectivity,aCellTypesArray,newFaces,newFaceLocations,aCellId,anIdList,
myStoreMapping,anOutId,myOut2InId,myIn2OutId);
+ anOutput->GetCellData()->CopyData(anInput->GetCellData(),aCellId,newId);
}
}
}
vtkIdType aType = anInput->GetCellType(aCellId);
if(myCellTypes.find(aType) != myCellTypes.end()){
if(myCellIds.find(aCellId) != myCellIds.end()){
- InsertCell(anInput,aConnectivity,aCellTypesArray,newFaces,newFaceLocations,aCellId,anIdList,
+ vtkIdType newId = InsertCell(anInput,aConnectivity,aCellTypesArray,newFaces,newFaceLocations,aCellId,anIdList,
myStoreMapping,anOutId,myOut2InId,myIn2OutId);
+ anOutput->GetCellData()->CopyData(anInput->GetCellData(),aCellId,newId);
}
}
}
vtkIdType aType = anInput->GetCellType(aCellId);
if(myCellTypes.find(aType) == myCellTypes.end()){
if(myCellIds.find(aCellId) == myCellIds.end()){
- InsertCell(anInput,aConnectivity,aCellTypesArray,newFaces,newFaceLocations,aCellId,anIdList,
+ vtkIdType newId = InsertCell(anInput,aConnectivity,aCellTypesArray,newFaces,newFaceLocations,aCellId,anIdList,
myStoreMapping,anOutId,myOut2InId,myIn2OutId);
+ anOutput->GetCellData()->CopyData(anInput->GetCellData(),aCellId,newId);
}
}
}
#include <QString>
#include <vtkCellArray.h>
+#include <vtkXMLImageDataReader.h>
#include <vtkImageData.h>
#include <vtkObjectFactory.h>
#include <vtkPointData.h>
#include <vtkSmartPointer.h>
#include <vtkTimerLog.h>
#include <vtkWindow.h>
+#include <vtkRenderWindow.h>
+#include <vtkCommand.h>
+#include <vtkCellData.h>
#ifndef WNT
# ifndef GLX_GLXEXT_LEGACY
#define GL_ARRAY_BUFFER_ARB 0x8892
#define GL_STATIC_DRAW_ARB 0x88E4
#endif
-
+typedef void (APIENTRYP PFNGLSHADERSOURCEARBPROC) (GLhandleARB shaderObj, GLsizei count, const GLcharARB* *string, const GLint *length);
+typedef GLhandleARB (APIENTRYP PFNGLCREATESHADEROBJECTARBPROC) (GLenum shaderType);
typedef void (APIENTRYP PFNGLBINDBUFFERARBPROC) (GLenum target, GLuint buffer);
typedef void (APIENTRYP PFNGLDELETEBUFFERSARBPROC) (GLsizei n, const GLuint *buffers);
typedef void (APIENTRYP PFNGLGENBUFFERSARBPROC) (GLsizei n, GLuint *buffers);
typedef void (APIENTRYP PFNGLBUFFERDATAARBPROC) (GLenum target, GLsizeiptrARB size, const GLvoid *data, GLenum usage);
+typedef void (APIENTRYP PFNGLCOMPILESHADERARBPROC) (GLhandleARB shaderObj);
+typedef GLhandleARB (APIENTRYP PFNGLCREATEPROGRAMOBJECTARBPROC) (void);
+typedef void (APIENTRYP PFNGLATTACHOBJECTARBPROC) (GLhandleARB containerObj, GLhandleARB obj);
+typedef void (APIENTRYP PFNGLLINKPROGRAMARBPROC) (GLhandleARB programObj);
+typedef void (APIENTRYP PFNGLUSEPROGRAMOBJECTARBPROC) (GLhandleARB programObj);
+typedef GLint (APIENTRYP PFNGLGETATTRIBLOCATIONPROC) (GLuint program, const GLchar *name);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBPOINTERPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer);
+typedef void (APIENTRYP PFNGLENABLEVERTEXATTRIBARRAYARBPROC) (GLuint index);
+typedef void (APIENTRYP PFNGLDISABLEVERTEXATTRIBARRAYARBPROC) (GLuint index);
+
+typedef GLfloat TBall;
+
+
+static PFNGLSHADERSOURCEARBPROC vglShaderSourceARB = NULL;
+static PFNGLCREATESHADEROBJECTARBPROC vglCreateShaderObjectARB = NULL;
+static PFNGLCOMPILESHADERARBPROC vglCompileShaderARB = NULL;
+static PFNGLCREATEPROGRAMOBJECTARBPROC vglCreateProgramObjectARB = NULL;
+static PFNGLATTACHOBJECTARBPROC vglAttachObjectARB = NULL;
+static PFNGLLINKPROGRAMARBPROC vglLinkProgramARB = NULL;
+static PFNGLUSEPROGRAMOBJECTARBPROC vglUseProgramObjectARB = NULL;
+
+static PFNGLGENBUFFERSARBPROC vglGenBuffersARB = NULL;
+static PFNGLBINDBUFFERARBPROC vglBindBufferARB = NULL;
+static PFNGLBUFFERDATAARBPROC vglBufferDataARB = NULL;
+static PFNGLDELETEBUFFERSARBPROC vglDeleteBuffersARB = NULL;
+static PFNGLGETATTRIBLOCATIONARBPROC vglGetAttribLocationARB = NULL;
+static PFNGLVERTEXATTRIBPOINTERPROC vglVertexAttribPointerARB = NULL;
+static PFNGLENABLEVERTEXATTRIBARRAYARBPROC vglEnableVertexAttribArrayARB = NULL;
+static PFNGLDISABLEVERTEXATTRIBARRAYARBPROC vglDisableVertexAttribArrayARB = NULL;
-static PFNGLGENBUFFERSARBPROC vglGenBuffersARB = NULL;
-static PFNGLBINDBUFFERARBPROC vglBindBufferARB = NULL;
-static PFNGLBUFFERDATAARBPROC vglBufferDataARB = NULL;
-static PFNGLDELETEBUFFERSARBPROC vglDeleteBuffersARB = NULL;
#ifndef WNT
#define GL_GetProcAddress( x ) glXGetProcAddressARB( (const GLubyte*)x )
#endif
#endif
+// ----------------------------------------------- Special Textures -----------------------------------
+// texture id for balls drawing
+#define BallTextureId 0
bool InitializeBufferExtensions()
{
+
+ vglShaderSourceARB = (PFNGLSHADERSOURCEARBPROC)GL_GetProcAddress( "glShaderSourceARB" );
+ if( !vglShaderSourceARB )
+ return false;
+
+ vglCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC)GL_GetProcAddress( "glCreateShaderObjectARB" );
+ if( !vglCreateShaderObjectARB )
+ return false;
+
+ vglCompileShaderARB = (PFNGLCOMPILESHADERARBPROC)GL_GetProcAddress( "glCompileShaderARB" );
+ if( !vglCompileShaderARB )
+ return false;
+
+ vglCreateProgramObjectARB = (PFNGLCREATEPROGRAMOBJECTARBPROC)GL_GetProcAddress( "glCreateProgramObjectARB" );
+ if( !vglCreateProgramObjectARB )
+ return false;
+
+ vglAttachObjectARB = (PFNGLATTACHOBJECTARBPROC)GL_GetProcAddress( "glAttachObjectARB" );
+ if( !vglAttachObjectARB )
+ return false;
+
+ vglLinkProgramARB = (PFNGLLINKPROGRAMARBPROC)GL_GetProcAddress( "glLinkProgramARB" );
+ if( !vglLinkProgramARB )
+ return false;
+
+ vglUseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC)GL_GetProcAddress( "glUseProgramObjectARB" );
+ if( !vglUseProgramObjectARB )
+ return false;
+
vglGenBuffersARB = (PFNGLGENBUFFERSARBPROC)GL_GetProcAddress( "glGenBuffersARB" );
if( !vglGenBuffersARB )
return false;
if( !vglDeleteBuffersARB )
return false;
+ vglGetAttribLocationARB = (PFNGLGETATTRIBLOCATIONARBPROC)GL_GetProcAddress( "glGetAttribLocation" );
+ if( !vglGetAttribLocationARB )
+ return false;
+
+ vglVertexAttribPointerARB = (PFNGLVERTEXATTRIBPOINTERPROC)GL_GetProcAddress( "glVertexAttribPointer" );
+ if( !vglVertexAttribPointerARB )
+ return false;
+
+ vglEnableVertexAttribArrayARB = (PFNGLENABLEVERTEXATTRIBARRAYARBPROC)GL_GetProcAddress( "glEnableVertexAttribArray" );
+ if(!vglEnableVertexAttribArrayARB)
+ return false;
+
+ vglDisableVertexAttribArrayARB = (PFNGLDISABLEVERTEXATTRIBARRAYARBPROC)GL_GetProcAddress( "glDisableVertexAttribArray" );
+
+ if(!vglDisableVertexAttribArrayARB)
+ return false;
+
+
return true;
};
+//-----------------------------------------------------------------------------
+char* readFromFile( std::string fileName )
+{
+ FILE* file = fopen( fileName.c_str(), "r" );
+
+ char* content = NULL;
+ int count = 0;
+
+ if( file != NULL )
+ {
+ fseek( file, 0, SEEK_END );
+ count = ftell( file );
+ rewind( file );
+
+ if( count > 0 )
+ {
+ content = ( char* )malloc( sizeof( char ) * ( count + 1 ) );
+ count = fread( content, sizeof( char ), count, file );
+ content[ count ] = '\0';
+ }
+ fclose( file );
+ }
+
+ return content;
+}
+
static bool IsBufferExtensionsInitialized = InitializeBufferExtensions();
//-----------------------------------------------------------------------------
this->MarkerType = VTK::MT_NONE;
this->MarkerScale = VTK::MS_NONE;
this->MarkerId = 0;
+ this->BallEnabled = false;
}
//-----------------------------------------------------------------------------
glDeleteTextures( 1, &PointSpriteTexture );
}
+//-----------------------------------------------------------------------------
+void VTKViewer_PolyDataMapper::InitShader()
+{
+ std::string fileName = std::string( getenv( "GUI_ROOT_DIR") ) +
+ "/share/salome/resources/gui/Vertex_Program_ARB.txt";
+
+ char* shader = readFromFile( fileName );
+
+ GLhandleARB VertexShader = vglCreateShaderObjectARB( GL_VERTEX_SHADER_ARB );
+ vglShaderSourceARB( VertexShader, 1, (const GLcharARB**)&shader, NULL );
+ vglCompileShaderARB( VertexShader );
+
+ this->VertexProgram = vglCreateProgramObjectARB();
+ vglAttachObjectARB( this->VertexProgram, VertexShader );
+
+ vglLinkProgramARB( this->VertexProgram );
+ free( shader );
+}
+
+
//-----------------------------------------------------------------------------
void VTKViewer_PolyDataMapper::SetMarkerEnabled( bool theMarkerEnabled )
{
this->Modified();
}
+//-----------------------------------------------------------------------------
+// Definition of structures and fuctions used in SetBallEnabled() method
+namespace VTK
+{
+ //----------------------------------------------------------------------------
+ vtkSmartPointer<vtkImageData> MakeTexture( const char* theMainTexture, const char* theAlphaTexture ) {
+ if( !theMainTexture || !theAlphaTexture )
+ return 0;
+
+ vtkXMLImageDataReader* aMainReader = vtkXMLImageDataReader::New();
+ vtkXMLImageDataReader* anAlphaReader = vtkXMLImageDataReader::New();
+
+ aMainReader->SetFileName( theMainTexture );
+ anAlphaReader->SetFileName( theAlphaTexture );
+
+ aMainReader->Update();
+ anAlphaReader->Update();
+
+ vtkImageData* aMainImageData = aMainReader->GetOutput();
+ vtkImageData* anAlphaImageData = anAlphaReader->GetOutput();
+
+ int* aMainImageSize = aMainImageData->GetDimensions();
+ int* anAlphaImageSize = anAlphaImageData->GetDimensions();
+ if(aMainImageSize[0] != anAlphaImageSize[0] || aMainImageSize[1] != anAlphaImageSize[1])
+ return NULL;
+
+ vtkSmartPointer<vtkImageData> aCompositeImageData = vtkImageData::New();
+ aCompositeImageData->Delete();
+
+ int aNbCompositeComponents = 4;
+ aCompositeImageData->SetDimensions(aMainImageSize);
+ aCompositeImageData->AllocateScalars( VTK_UNSIGNED_CHAR, aNbCompositeComponents );
+
+ unsigned char* aMainDataPtr = (unsigned char*)aMainImageData->GetScalarPointer();
+ unsigned char* anAlphaDataPtr = (unsigned char*)anAlphaImageData->GetScalarPointer();
+ unsigned char *aCompositeDataPtr = (unsigned char * )aCompositeImageData->GetScalarPointer();
+
+ int aNbMainComponents = aMainImageData->GetNumberOfScalarComponents();
+ int aNbAlphaComponents = anAlphaImageData->GetNumberOfScalarComponents();
+ int aCompositeSize = aMainImageSize[0] * aMainImageSize[1] * aNbCompositeComponents;
+
+ int aMainId = 0, anAlphaId = 0, aCompositeId = 0;
+ for(; aCompositeId < aCompositeSize;) {
+ aCompositeDataPtr[aCompositeId] = aMainDataPtr[aMainId];
+ aCompositeDataPtr[aCompositeId + 1] = aMainDataPtr[aMainId + 1];
+ aCompositeDataPtr[aCompositeId + 2] = aMainDataPtr[aMainId + 2];
+ aCompositeDataPtr[aCompositeId + 3] = anAlphaDataPtr[anAlphaId];
+
+ aMainId += aNbMainComponents;
+ anAlphaId += aNbAlphaComponents;
+ aCompositeId += aNbCompositeComponents;
+ }
+ aMainReader->Delete();
+ anAlphaReader->Delete();
+ return aCompositeImageData;
+ }
+}
+
+//-----------------------------------------------------------------------------
+bool VTKViewer_PolyDataMapper::GetBallEnabled()
+{
+ return this->BallEnabled;
+}
+//-----------------------------------------------------------------------------
+void VTKViewer_PolyDataMapper::SetBallEnabled( bool theBallEnabled )
+{
+ if( this->BallEnabled == theBallEnabled )
+ return;
+ else
+ this->BallEnabled = theBallEnabled;
+
+ if(!this->BallEnabled) {
+ this->ImageData = NULL;
+ }
+
+ if(this->BallEnabled) {
+ if(this->SpecialTextures.find(BallTextureId) == SpecialTextures.end()){
+ QString aMainTexture = getenv( "GUI_ROOT_DIR" );
+ aMainTexture.append("/share/salome/resources/gui/sprite_texture.vti");
+
+ QString anAlphaTexture = getenv( "GUI_ROOT_DIR" );
+ anAlphaTexture.append( "/share/salome/resources/gui/sprite_alpha.vti" );
+ vtkSmartPointer<vtkImageData> aTextureValue = VTK::MakeTexture( aMainTexture.toLatin1().constData(), anAlphaTexture.toLatin1().constData() );
+ this->SpecialTextures[BallTextureId] = aTextureValue;
+ }
+ this->ImageData = this->SpecialTextures[BallTextureId];
+ }
+ this->Modified();
+}
+
//-----------------------------------------------------------------------------
void VTKViewer_PolyDataMapper::SetMarkerStd( VTK::MarkerType theMarkerType, VTK::MarkerScale theMarkerScale )
{
char* ext = (char*)glGetString( GL_EXTENSIONS );
if( !IsBufferExtensionsInitialized ||
strstr( ext, "GL_ARB_point_sprite" ) == NULL ||
- strstr( ext, "GL_ARB_vertex_buffer_object" ) == NULL )
+ strstr( ext, "GL_ARB_vertex_buffer_object" ) == NULL ||
+ strstr( ext, "GL_ARB_shader_objects") == NULL )
{
MESSAGE("Initializing ARB extensions failed");
return ES_Error;
}
+ if( this->BallEnabled )
+ this->InitShader();
+
return ES_Ok;
}
glEnable( GL_DEPTH_TEST );
glEnable( GL_ALPHA_TEST );
- glAlphaFunc( GL_GREATER, 0.0 );
+ if(!this->BallEnabled) {
+ glAlphaFunc( GL_GREATER, 0.0 );
+ }
+ else {
+ glAlphaFunc( GL_GREATER, 0.5 );
+ }
glDisable( GL_LIGHTING );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
- glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
- glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
+
+ if(this->BallEnabled) {
+ glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+ glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+ } else {
+ glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
+ glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
+ }
int* aSize = this->ImageData->GetDimensions();
unsigned char* dataPtr = (unsigned char*)this->ImageData->GetScalarPointer();
//-----------------------------------------------------------------------------
void VTKViewer_PolyDataMapper::RenderPiece( vtkRenderer* ren, vtkActor* act )
{
- bool isUsePointSprites = this->MarkerEnabled && this->MarkerType != VTK::MT_NONE;
+ bool isUsePointSprites = (this->MarkerEnabled && this->MarkerType != VTK::MT_NONE) ||
+ this->BallEnabled;
if( isUsePointSprites )
{
if( this->ExtensionsInitialized == ES_None )
this->InitTextures();
}
- MAPPER_SUPERCLASS::RenderPiece( ren, act );
+ if(!this->BallEnabled) {
+ MAPPER_SUPERCLASS::RenderPiece( ren, act );
+ if( isUsePointSprites )
+ this->CleanupPointSprites();
+ } else {
+ vtkIdType numPts;
+ vtkPolyData *input= this->GetInput();
+
+ //
+ // make sure that we've been properly initialized
+ //
+ if (ren->GetRenderWindow()->CheckAbortStatus())
+ return;
+
+ if ( input == NULL )
+ {
+ vtkErrorMacro(<< "No input!");
+ return;
+ }
+ else
+ {
+ this->InvokeEvent(vtkCommand::StartEvent,NULL);
+ this->Update();
+ this->InvokeEvent(vtkCommand::EndEvent,NULL);
+ numPts = input->GetNumberOfPoints();
+ }
+
+ if (numPts == 0)
+ {
+ vtkDebugMacro(<< "No points!");
+ return;
+ }
+
+ // make sure our window is current
+ ren->GetRenderWindow()->MakeCurrent();
+
+
+ vglUseProgramObjectARB( this->VertexProgram );
+
+ //
+ // if something has changed regenerate colors and display lists
+ // if required
+ //
+ int noAbort=1;
+ if ( this->GetMTime() > this->BuildTime ||
+ input->GetMTime() > this->BuildTime ||
+ act->GetProperty()->GetMTime() > this->BuildTime ||
+ ren->GetRenderWindow() != this->LastWindow)
+ {
+ // sets this->Colors as side effect
+ this->MapScalars( act->GetProperty()->GetOpacity() );
+
+ if (!this->ImmediateModeRendering &&
+ !this->GetGlobalImmediateModeRendering())
+ {
+ this->ReleaseGraphicsResources(ren->GetRenderWindow());
+ this->LastWindow = ren->GetRenderWindow();
+
+ // get a unique display list id
+ this->ListId = glGenLists(1);
+ glNewList(this->ListId,GL_COMPILE);
+
+ noAbort = this->Draw(ren,act);
+ glEndList();
+
+ // Time the actual drawing
+ this->Timer->StartTimer();
+ glCallList(this->ListId);
+ this->Timer->StopTimer();
+ }
+ else
+ {
+ this->ReleaseGraphicsResources(ren->GetRenderWindow());
+ this->LastWindow = ren->GetRenderWindow();
+ }
+ if (noAbort)
+ this->BuildTime.Modified();
+ }
+ // if nothing changed but we are using display lists, draw it
+ else
+ {
+ if (!this->ImmediateModeRendering &&
+ !this->GetGlobalImmediateModeRendering())
+ {
+ // Time the actual drawing
+ this->Timer->StartTimer();
+ glCallList(this->ListId);
+ this->Timer->StopTimer();
+ }
+ }
+
+ // if we are in immediate mode rendering we always
+ // want to draw the primitives here
+ if (this->ImmediateModeRendering ||
+ this->GetGlobalImmediateModeRendering())
+ {
+ // sets this->Colors as side effect
+ this->MapScalars( act->GetProperty()->GetOpacity() );
+
+ // Time the actual drawing
+ this->Timer->StartTimer();
+ this->Draw(ren,act);
+ this->Timer->StopTimer();
+ }
+
+ this->TimeToDraw = (float)this->Timer->GetElapsedTime();
+
+ // If the timer is not accurate enough, set it to a small
+ // time so that it is not zero
+ if ( this->TimeToDraw == 0.0 )
+ this->TimeToDraw = 0.0001;
+
+ vglUseProgramObjectARB( 0 );
- if( isUsePointSprites )
this->CleanupPointSprites();
+ }
}
//-----------------------------------------------------------------------------
TColorFunctorBase* theColorFunctor,
TVertex* theVertexArr,
vtkIdType &theCellId,
- vtkIdType &theVertexId )
+ vtkIdType &theVertexId,
+ TBall* theBallArr,
+ vtkDataArray* theDiamArray)
{
vtkIdType* ptIds = theCells->GetPointer();
vtkIdType* endPtIds = ptIds + theCells->GetNumberOfConnectivityEntries();
+ bool mapBalls = false;
+ if(theBallArr && theDiamArray) {
+ mapBalls = true;
+ }
+
while ( ptIds < endPtIds ) {
vtkIdType nPts = *ptIds;
++ptIds;
++ptIds;
--nPts;
}
+
+ if(mapBalls){
+ theBallArr[theCellId] = (TBall)theDiamArray->GetTuple(theCellId)[0];
+ }
++theCellId;
}
void DrawCellsPoints( vtkPolyData* theInput,
vtkPoints* thePoints,
TColorFunctorBase* theColorFunctor,
- TVertex* theVertexArr )
+ TVertex* theVertexArr,
+ TBall* theBallArr)
{
vtkIdType aCellId = 0, aVertexId = 0;
TCoordinates* aStartPoints = (TCoordinates*)thePoints->GetVoidPointer(0);
+ vtkDataArray* aDiams = theInput->GetCellData() ? theInput->GetCellData()->GetScalars() : 0;
- if ( vtkCellArray* aCellArray = theInput->GetVerts() )
- DrawPoints( aStartPoints, aCellArray, theColorFunctor, theVertexArr, aCellId, aVertexId );
+ if ( vtkCellArray* aCellArray = theInput->GetVerts() ) {
+ DrawPoints( aStartPoints, aCellArray, theColorFunctor, theVertexArr, aCellId, aVertexId, theBallArr, aDiams);
+ }
if ( vtkCellArray* aCellArray = theInput->GetLines() )
- DrawPoints( aStartPoints, aCellArray, theColorFunctor, theVertexArr, aCellId, aVertexId );
+ DrawPoints( aStartPoints, aCellArray, theColorFunctor, theVertexArr, aCellId, aVertexId, theBallArr, aDiams);
if ( vtkCellArray* aCellArray = theInput->GetPolys() )
- DrawPoints( aStartPoints, aCellArray, theColorFunctor, theVertexArr, aCellId, aVertexId );
+ DrawPoints( aStartPoints, aCellArray, theColorFunctor, theVertexArr, aCellId, aVertexId, theBallArr, aDiams);
if ( vtkCellArray* aCellArray = theInput->GetStrips() )
- DrawPoints( aStartPoints, aCellArray, theColorFunctor, theVertexArr, aCellId, aVertexId );
+ DrawPoints( aStartPoints, aCellArray, theColorFunctor, theVertexArr, aCellId, aVertexId, theBallArr, aDiams);
}
} // namespace VTK
//-----------------------------------------------------------------------------
int VTKViewer_PolyDataMapper::Draw( vtkRenderer* ren, vtkActor* act )
-{
- if( !this->MarkerEnabled || this->MarkerType == VTK::MT_NONE || !this->ImageData.GetPointer() )
+{
+ if( (!this->MarkerEnabled || this->MarkerType == VTK::MT_NONE || !this->ImageData.GetPointer()) && !this->BallEnabled)
return MAPPER_SUPERCLASS::Draw( ren, act );
vtkUnsignedCharArray* colors = NULL;
if ( this->Colors )
{
- colors = this->Colors;
- if ( (this->ScalarMode == VTK_SCALAR_MODE_USE_CELL_DATA ||
- this->ScalarMode == VTK_SCALAR_MODE_USE_CELL_FIELD_DATA ||
- !input->GetPointData()->GetScalars() )
- && this->ScalarMode != VTK_SCALAR_MODE_USE_POINT_FIELD_DATA)
- cellScalars = 1;
+ if(!this->BallEnabled) {
+ colors = this->Colors;
+ if ( (this->ScalarMode == VTK_SCALAR_MODE_USE_CELL_DATA ||
+ this->ScalarMode == VTK_SCALAR_MODE_USE_CELL_FIELD_DATA ||
+ !input->GetPointData()->GetScalars() )
+ && this->ScalarMode != VTK_SCALAR_MODE_USE_POINT_FIELD_DATA )
+ cellScalars = 1;
+ }
}
{
vtkIdType aTotalConnectivitySize = 0;
+ vtkIdType aNbCells = 0;
- if ( vtkCellArray* aCellArray = input->GetVerts() )
+ if ( vtkCellArray* aCellArray = input->GetVerts() ) {
aTotalConnectivitySize += aCellArray->GetNumberOfConnectivityEntries() - aCellArray->GetNumberOfCells();
+ aNbCells += aCellArray->GetNumberOfCells();
+ }
- if ( vtkCellArray* aCellArray = input->GetLines() )
+ if ( vtkCellArray* aCellArray = input->GetLines() ) {
aTotalConnectivitySize += aCellArray->GetNumberOfConnectivityEntries() - aCellArray->GetNumberOfCells();
+ aNbCells += aCellArray->GetNumberOfCells();
+ }
- if ( vtkCellArray* aCellArray = input->GetPolys() )
+ if ( vtkCellArray* aCellArray = input->GetPolys() ) {
aTotalConnectivitySize += aCellArray->GetNumberOfConnectivityEntries() - aCellArray->GetNumberOfCells();
+ aNbCells += aCellArray->GetNumberOfCells();
+ }
- if ( vtkCellArray* aCellArray = input->GetStrips() )
+ if ( vtkCellArray* aCellArray = input->GetStrips() ) {
aTotalConnectivitySize += aCellArray->GetNumberOfConnectivityEntries() - aCellArray->GetNumberOfCells();
+ aNbCells += aCellArray->GetNumberOfCells();
+ }
if ( aTotalConnectivitySize > 0 ) {
VTK::TVertex* aVertexArr = new VTK::TVertex[ aTotalConnectivitySize ];
+
+ TBall* aBallArray = 0;
+
+ if(this->BallEnabled) {
+ aBallArray = new TBall[aNbCells];
+ }
int* aSize = this->ImageData->GetDimensions();
glPointSize( std::max( aSize[0], aSize[1] ) );
aColorFunctor = new VTK::TPropertyColor( prop );
}
if ( points->GetDataType() == VTK_FLOAT )
- VTK::DrawCellsPoints< float >( input, points, aColorFunctor, aVertexArr );
+ VTK::DrawCellsPoints< float >( input, points, aColorFunctor, aVertexArr, aBallArray );
else
- VTK::DrawCellsPoints< double >( input, points, aColorFunctor, aVertexArr );
+ VTK::DrawCellsPoints< double >( input, points, aColorFunctor, aVertexArr, aBallArray );
delete aColorFunctor;
}
if( this->ExtensionsInitialized == ES_Ok ) {
- GLuint aBufferObjectID = 0;
+ GLuint aBufferObjectID, aDiamsID = 0;
+ GLint attribute_diams = -1;
vglGenBuffersARB( 1, &aBufferObjectID );
vglBindBufferARB( GL_ARRAY_BUFFER_ARB, aBufferObjectID );
delete [] aVertexArr;
vglBindBufferARB( GL_ARRAY_BUFFER_ARB, 0 );
- vglBindBufferARB( GL_ARRAY_BUFFER_ARB, aBufferObjectID );
+ vglBindBufferARB( GL_ARRAY_BUFFER_ARB, aBufferObjectID );
glColorPointer( 4, GL_FLOAT, sizeof(VTK::TVertex), (void*)0 );
glVertexPointer( 3, GL_FLOAT, sizeof(VTK::TVertex), (void*)(4*sizeof(GLfloat)) );
glEnableClientState( GL_VERTEX_ARRAY );
glEnableClientState( GL_COLOR_ARRAY );
-
+
+ if(this->BallEnabled) {
+ vglGenBuffersARB( 2, &aDiamsID);
+ vglBindBufferARB( GL_ARRAY_BUFFER_ARB, aDiamsID);
+
+ int aDiamsSize = sizeof(TBall)*aNbCells;
+ vglBufferDataARB( GL_ARRAY_BUFFER_ARB, aDiamsSize, aBallArray, GL_STATIC_DRAW_ARB);
+
+ delete [] aBallArray;
+ vglBindBufferARB( GL_ARRAY_BUFFER_ARB, 0 );
+ vglBindBufferARB( GL_ARRAY_BUFFER_ARB, aDiamsID );
+
+ attribute_diams = vglGetAttribLocationARB(this->VertexProgram, "diameter");
+ vglEnableVertexAttribArrayARB(attribute_diams);
+ vglBindBufferARB(GL_ARRAY_BUFFER, aDiamsID);
+ vglVertexAttribPointerARB(
+ attribute_diams, // attribute
+ 1, // number of elements per vertex, here (diameter)
+ GL_FLOAT, // the type of each element
+ GL_FALSE, // take our values as-is
+ 0, // no extra data between each position
+ 0 // offset of first element
+ );
+ }
+
glDrawArrays( GL_POINTS, 0, aTotalConnectivitySize );
glDisableClientState( GL_COLOR_ARRAY );
- glDisableClientState( GL_VERTEX_ARRAY );
-
+ glDisableClientState( GL_VERTEX_ARRAY );
vglDeleteBuffersARB( 1, &aBufferObjectID );
+
+ if(this->BallEnabled) {
+ vglDisableVertexAttribArrayARB(attribute_diams);
+ vglDeleteBuffersARB( 2, &aDiamsID );
+ }
+
} else { // there are no extensions
glColorPointer( 4, GL_FLOAT, sizeof(VTK::TVertex), aVertexArr );
glVertexPointer( 3, GL_FLOAT, sizeof(VTK::TVertex),
