vtkHardwareSelector.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkHardwareSelector.h

  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.

=========================================================================*/
#ifndef __vtkHardwareSelector_h
#define __vtkHardwareSelector_h

#include "vtkRenderingCoreModule.h" // For export macro
#include "vtkObject.h"

class vtkRenderer;
class vtkSelection;
class vtkProp;
class vtkTextureObject;

class VTKRENDERINGCORE_EXPORT vtkHardwareSelector : public vtkObject
{
public:

  struct PixelInformation
    {
    bool Valid;
    int ProcessID;
    int PropID;
    vtkProp* Prop;
    unsigned int CompositeID;
    vtkIdType AttributeID;
    PixelInformation():
      Valid(false),
      ProcessID(-1),
      Prop(NULL),
      CompositeID(0),
      AttributeID(-1) {}
    };

public:
  static vtkHardwareSelector* New();
  vtkTypeMacro(vtkHardwareSelector, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent);


  void SetRenderer(vtkRenderer*);
  vtkGetObjectMacro(Renderer, vtkRenderer);


  vtkSetVector4Macro(Area, unsigned int);
  vtkGetVector4Macro(Area, unsigned int);


  vtkSetMacro(FieldAssociation, int);
  vtkGetMacro(FieldAssociation, int);


  vtkSetMacro(UseProcessIdFromData, bool);
  vtkGetMacro(UseProcessIdFromData, bool);

  vtkSelection* Select();


  virtual bool CaptureBuffers();
  PixelInformation GetPixelInformation(unsigned int display_position[2])
    { return this->GetPixelInformation(display_position, 0); }
  PixelInformation GetPixelInformation(unsigned int display_position[2],
    int maxDist);
  void ClearBuffers()
    { this->ReleasePixBuffers(); }


  bool GetPixelInformation(unsigned int display_position[2],
    int& processId, vtkIdType& attrId, vtkProp*& prop);


  bool GetPixelInformation(unsigned int display_position[2],
    int& processId, vtkIdType& attrId, vtkProp*& prop, int maxDist);

  void RenderCompositeIndex(unsigned int index);

  void RenderAttributeId(vtkIdType attribid);

  void RenderProcessId(unsigned int processid);

  int Render(vtkRenderer* renderer, vtkProp** propArray, int propArrayCount);


  void BeginRenderProp();
  void EndRenderProp();


  vtkSetMacro(ProcessID, int);
  vtkGetMacro(ProcessID, int);


  vtkGetMacro(CurrentPass, int);


  virtual vtkSelection* GenerateSelection()
    { return GenerateSelection(this->Area); }
  virtual vtkSelection* GenerateSelection(unsigned int r[4])
    { return GenerateSelection(r[0], r[1], r[2], r[3]); }
  virtual vtkSelection* GenerateSelection(
    unsigned int x1, unsigned int y1,
    unsigned int x2, unsigned int y2);

  vtkProp* GetPropFromID(int id);

//BTX
  enum PassTypes
    {
    PROCESS_PASS,
    ACTOR_PASS,
    COMPOSITE_INDEX_PASS,
    ID_LOW24,
    ID_MID24,
    ID_HIGH16,
    MAX_KNOWN_PASS = ID_HIGH16,
    MIN_KNOWN_PASS = PROCESS_PASS
    };
protected:
  vtkHardwareSelector();
  ~vtkHardwareSelector();

  static void Convert(int id, float tcoord[3])
    {
      tcoord[0] = static_cast<float>((id & 0xff)/255.0);
      tcoord[1] = static_cast<float>(((id & 0xff00) >> 8)/255.0);
      tcoord[2] = static_cast<float>(((id & 0xff0000) >> 16)/255.0);
    }

  int Convert(unsigned long offset, unsigned char* pb)
    {
    if (!pb)
      {
      return 0;
      }

    offset = offset * 3;
    unsigned char rgb[3];
    rgb[0] = pb[offset];
    rgb[1] = pb[offset+1];
    rgb[2] = pb[offset+2];
    int val = 0;
    val |= rgb[2];
    val = val << 8;
    val |= rgb[1];
    val = val << 8;
    val |= rgb[0];
    return val;
    }


  int Convert(unsigned int pos[2], unsigned char* pb)
    { return this->Convert(pos[0], pos[1], pb); }
  int Convert(int xx, int yy, unsigned char* pb)
    {
    if (!pb)
      {
      return 0;
      }
    int offset = (yy * static_cast<int>(this->Area[2]-this->Area[0]+1) + xx) * 3;
    unsigned char rgb[3];
    rgb[0] = pb[offset];
    rgb[1] = pb[offset+1];
    rgb[2] = pb[offset+2];
    int val = 0;
    val |= rgb[2];
    val = val << 8;
    val |= rgb[1];
    val = val << 8;
    val |= rgb[0];
    return val;
    }

  vtkIdType GetID(int low24, int mid24, int high16)
    {
    vtkIdType val = 0;
    val |= high16;
    val = val << 24;
    val |= mid24;
    val = val << 24;
    val |= low24;
    return val;
    }

  virtual bool PassRequired(int pass);

  bool IsPropHit(int propid);


  virtual int GetPropID(int idx, vtkProp* vtkNotUsed(prop))
    { return idx; }

  virtual void BeginSelection();
  virtual void EndSelection();

  void SavePixelBuffer(int passNo);
  void BuildPropHitList(unsigned char* rgbData);


  void ReleasePixBuffers();
  vtkRenderer* Renderer;
  unsigned int Area[4];
  int FieldAssociation;
  bool UseProcessIdFromData;
  vtkIdType MaxAttributeId;

  // At most 10 passes.
  unsigned char* PixBuffer[10];
  int ProcessID;
  int CurrentPass;
  int InPropRender;
private:
  vtkHardwareSelector(const vtkHardwareSelector&); // Not implemented.
  void operator=(const vtkHardwareSelector&); // Not implemented.

  int PropID;
  class vtkInternals;
  vtkInternals* Internals;
//ETX
};

#endif