1. 28 Nov, 2017 1 commit
    • Ken Martin's avatar
      add an executable to do opengl detection · 9eba3269
      Ken Martin authored
      Added an executable that is always built regardless
      of if testing is on that checkes for OpenGL2 support.
      This can be used to help diagnose problems when users
      have a build using VTK that is not working and testing
      is off as it is by default.
      9eba3269
  2. 22 Nov, 2017 1 commit
  3. 15 Nov, 2017 1 commit
  4. 02 Oct, 2017 1 commit
  5. 02 Aug, 2017 1 commit
    • Ken Martin's avatar
      add an executable to test for windows opengl support · 6a83f3ae
      Ken Martin authored
      this executable can be used to test if the default
      opengl on a system supports OpenGL 3.2 or later.
      If so the executable will return a 0 otherwise 1.
      
      If run with a -v it will display a dialog with some
      additional informaiton.
      6a83f3ae
  6. 18 Jul, 2017 2 commits
    • Utkarsh Ayachit's avatar
      Add option to prefer headless RenderWindows. · b68a3088
      Utkarsh Ayachit authored
      When `VTK_DEFAULT_RENDER_WINDOW_HEADLESS` is turned on, an option
      available only when onscreen and headless rendering is support by the
      build, the object factor will create the headless RenderWindow
      implementation by default.
      b68a3088
    • Utkarsh Ayachit's avatar
      Cleanup offscreen rendering support in VTK. · d0e7aab3
      Utkarsh Ayachit authored
      This commit cleans up offscreen rendering support in VTK. This includes
      several changes.
      
      1. It makes EGL support independent of onscreen GL
         support. It's now possible to enable EGL and GLX in same build of
         VTK, for example, so long as the two use shared GL-dispatch
         mechanism.  Previously, EGL could not be enabled together with GLX
         (i.e.  `VTK_USE_X` set to ON). These changes allow for that
         configuration.
      
      2. `VTK_USE_OFFSCREEN_EGL` is replaced by `VTK_OPENGL_HAS_EGL`.
          This is consistent with `VTK_OPENGL_HAS_OSMESA` flag. And also
          in similar vein to changes to `FindOpenGL.cmake` where EGL
          becomes a component of `find_package(OpenGL)`.
      
      3. `VTK_EGL_DEVICE_INDEX` has been replaced by
         `VTK_DEFAULT_EGL_DEVICE_INDEX` since it only affect the default
         value, and doesn't preclude users from manually specifying the
         device index.
      
      4. `VTK_USE_OFFSCREEN` has been replaced by
         `VTK_DEFAULT_RENDER_WINDOW_OFFSCREEN`, since similar to `3`
         this option was only intended to affect the default value.
      
      5. Simplified `FindEGL.cmake`. Apps don't need to link against
         `gldispatch` library and hence removed it and created an
         imported target to simplify use.
      
      6. For all changes to CMake variables, we put out `DEPRECATION`
         messages if old variables are used.
      
      7. When `VTK_USE_X` and `VTK_OPENGL_HAS_EGL` or
         `VTK_OPENGL_HAS_OSMESA` in ON, following things happen:
         i.   The object-factory simply returns the X-based (or
              onscreen) render window i.e. `vtkXOpenGLRenderWindow`.
         ii.  To create one of the offscreen render windows, one can
              manually instantiate them e.g. by explicitly
              instantiating `vtkEGLRenderWindow`.
              `vtkXOpenGLRenderWindow` has implementation to swap to
              OSMesa if `SetUseOffscreen(true)` is called.
         iii. As soon any off-screen features are enabled, `glew`
              uses the offscreen library APIs to get OpenGL function pointers
              irrespective of how the active context was initialized.
      d0e7aab3
  7. 14 Jun, 2017 1 commit
  8. 13 Jun, 2017 1 commit
    • Ken Martin's avatar
      add a framebuffer pass to support rendering into a fo · 3a7b6bf9
      Ken Martin authored
      This way you can render into a Frambuffer Object and then
      at the last step it does a blit to the outer framebuffer.
      Typically the screen/window but it could be another FO.
      
      Also add a FramebufferDepthPeelingPass that is desgined to
      work within a framebuffer pass (or similar). This is the
      only depth peeling that will work on OpenGL ES3 right now.
      3a7b6bf9
  9. 30 May, 2017 1 commit
    • Ken Martin's avatar
      add better support for cube map textures and mipmaps · c4875273
      Ken Martin authored
      This topic adds cubemap and mipmap options to vtkTexture
      It updates the polydatamapper to always declare and bind
      any textures assigned to the actor/property even if
      there are no texture coordinates (the shader may compute them)
      
      mipmaps are supported for cubemaps on OpenGL 4 or later.
      For earlier versions the request is ignored.
      c4875273
  10. 05 May, 2017 1 commit
  11. 20 Jan, 2017 1 commit
    • Alexis Girault's avatar
      Introduce a Vertex Buffer Object Cache · fd8bfb59
      Alexis Girault authored
      Based on initial work from Alexi
      
      Add cache so that VBO can be shared and
      updated more  quickly.
      
      Introduce the notion of a VBOGroup this is a
      convenience for mappers to keep track of the vbos
      they are using and the data arrays they are associated
      with. You do not need to use a VBOgroup but it makes
      it easier for mappers that can have multiple VBOs.
      fd8bfb59
  12. 13 Dec, 2016 1 commit
    • Alvaro Sanchez's avatar
      Made vtkValuePass use vtkOpenGLRenderPass API. · f326b152
      Alvaro Sanchez authored
      vtkValuePassHelper moved into vtkValuePass. All the related vtkMapper code
      (invertible lut) also moved into an internal class of this pass.
      
      Removed the invertible lut code path from vtkMapper.
      
      Changed various set/get methods to vtkSetGet macros.
      f326b152
  13. 10 Nov, 2016 1 commit
    • Ken Martin's avatar
      Remove the old FBO compatability Code · 57bd525c
      Ken Martin authored
      The prior commit contains the merging of the FBO and
      FBO2 functionality. This commit removes a fair amount of
      the old FBO functionality to keep the API clean and encourage
      people to use FOs in a consistent manner.
      57bd525c
  14. 01 Nov, 2016 1 commit
    • Ken Martin's avatar
      Remove ES2 support for VTK 8.0 · 0f750114
      Ken Martin authored
      ES2 is causing headaches and code mess and is
      getting old. Remove for 8.0 so we can focus on
      more modern APIs. Most Apple and Adroid devices
      from the past 4 years support ES3.
      0f750114
  15. 11 Oct, 2016 1 commit
    • Brad King's avatar
      Android: Port build system to CMake 3.7 capabilities · 9c744b13
      Brad King authored
      CMake 3.7 adds support for cross-compiling to Android without a complex
      toolchain file.  Port our main CMake build system to work without the
      `android.toolchain.cmake` file:
      
      ```
      $ cmake ../VTK \
          -DCMAKE_SYSTEM_NAME=Android \
          -DCMAKE_ANDROID_NDK=/path/to/ndk \
          -DVTKCompileTools_DIR=/path/to/vtk-compile-tools \
          -DOPENGL_ES_VERSION=3.0 \
          -DVTK_Group_StandAlone=OFF
      ```
      9c744b13
  16. 10 Oct, 2016 1 commit
    • Ken Martin's avatar
      ifdef out valuepass code on ES2 · 048f89ab
      Ken Martin authored
      ValuePass was having issues with OpenGL ES2 so
      this topic ifdefs the code on that platform.  The result
      is fairly messy so it really needs another pass at
      some point to do it right. This is a quick fix as
      we are heading to a release.
      048f89ab
  17. 07 Oct, 2016 1 commit
  18. 05 Oct, 2016 2 commits
  19. 20 Sep, 2016 3 commits
    • David C. Lonie's avatar
      Exclude vtkOpenGLRenderTimer from wrapping. · 548990af
      David C. Lonie authored
      It's not a vtkObject, so CS wrapping fails.
      548990af
    • David C. Lonie's avatar
      Add vtkOpenGLRenderTimer. · 2570bf33
      David C. Lonie authored
      Uses GL_TIMESTAMP queries to provide asynch, nestable GPU timings.
      2570bf33
    • David C. Lonie's avatar
      Add an FXAA implementation. · fc9878ef
      David C. Lonie authored
      FXAA is an antialiasing technique that is applied in a post-processing
      pass. This implementation:
      
      - Is a single-pass fragment shader.
      - Detects edges.
      - Searches for edge endpoints.
      - Interpolates colors along the edge to give a smooth, antialiased
        color gradient.
      - Detects and corrects sub-pixel antialiasing.
      fc9878ef
  20. 19 Sep, 2016 2 commits
    • Alvaro Sanchez's avatar
      Fixed broken tests and updated documentation. · f133d013
      Alvaro Sanchez authored
      Moved member variables of vtkValuePass and ValuePassHelper into internals. Added
      a secondary baseline image for the case when the required extensions are not
      supported and vtkValuePass falls back to INVERTIBLE_LUT.
      f133d013
    • Alvaro Sanchez's avatar
      Added vtkValuePass::FLOATING_POINT for point data. · 0983eaba
      Alvaro Sanchez authored
      A field array of point data is uploaded as a vertex attribute and rendered to a
      float FBO member of the vtkValuePass. The legacy value rendering mode is still
      supported as INVERTIBLE_LUT.
      0983eaba
  21. 18 Sep, 2016 1 commit
    • Ken Martin's avatar
      Rework the CompositePolyDataMapper2 · 7912d340
      Ken Martin authored
      The old approach used a fast path for a very narrow set of
      conditions and then used a slow path for everything else.
      This approach required two sets of code,
      
      - GenericCompositePolydataMapper2
      - CompositePolyDataMapper2
      
      and had performance issues as the slow path was slower
      than OpenGL1 for some cases. This reworking consolidates
      the two approach together. The basic approach is that
      all blocks with the same VBO structure get grouped together
      and rendered as one. The number of different VBO structures is
      small so this results in a a small number of things to render.
      
      Each of those things (handled with a Helper class) gets rendered
      using its own VBO and IBOs with special code to handle the cases
      where uniforms have to be changed between blocks etc.
      
      The results are generally much faster. Some additional
      optimizations have resulted in further performance improvements.
      Generally this new class is as fast as the old fast path and
      tens to hundreds of times faster for the slow path.
      
      This class is still complex and could probably be reworked
      another three times. The complexity is largly driven by
      how complex the task is as each block can have different
      primitives, point/cell data arrays, etc.
      
      This topic adds four more tests for this class. As this
      class is the workhourse for ParaView it really needs far
      more testing in VTK. The three additional tests cover
      some use cases I know tend to cause issues.
      
      At the same time this topic changes how point picking is
      done to prevent some bad behavior. The old approach
      rendered surfaces for all passes up to the primId pass.
      The problem with that is that the point pass rendering may
      not match up with the surface rendering resulting in point
      Ids associated with incoreect composite/prop/process ids.
      It mixes two sets of data haphazzardly. Very bad. This
      topic cuases all point selection to be done by rendering
      points.
      7912d340
  22. 02 Sep, 2016 1 commit
  23. 15 Aug, 2016 1 commit
  24. 02 Jul, 2016 1 commit
    • Ken Martin's avatar
      add opengl gpu image processing support · c3a6dfa9
      Ken Martin authored
      Provide an example of how to use the GPU to
      do some image processing. Includes a helper class
      that handles some of the common tasks that you would
      need to do for image processing.
      c3a6dfa9
  25. 18 Apr, 2016 1 commit
    • David C. Lonie's avatar
      Fix dual depth peeling on ES. · d4700bf0
      David C. Lonie authored
      Disable dual depth peeling on ES2 -- ES2 does not support GL_MAX blending, which is essential for the peeling
      passes.
      
      It looks like ES3 provides everything we need by default.
      d4700bf0
  26. 11 Apr, 2016 1 commit
    • David C. Lonie's avatar
      Add vtkDualDepthPeelingPass. · 19d945f7
      David C. Lonie authored
      This implements a new depth peeling algorithm that peels layers of
      fragments from both the front and back of the translucent geometry at
      once.
      
      This also introduces vtkOpenGLRenderPass, which provides a virtual API
      that allows custom shader code replacements without the need to edit
      all mappers.
      
      The older vtkDepthPeelingPass has been updated to use the new
      vtkOpenGLRenderPass API, and is left in VTK as a fallback for drivers
      that lack support for the dual peeling features (floating point textures
      in particular).
      19d945f7
  27. 23 Mar, 2016 1 commit
    • Dave DeMarle's avatar
      Allow backend agnostic render passes. · de7ea53b
      Dave DeMarle authored
      Promoting RenderPass and thus FrameBufferObject and RenderState to
      Rendering Core allows other modules to define RenderPasses that are
      are independent of RenderingBackend choice.
      de7ea53b
  28. 08 Mar, 2016 1 commit
  29. 21 Jan, 2016 1 commit
  30. 18 Jan, 2016 2 commits
  31. 13 Nov, 2015 1 commit
  32. 29 Oct, 2015 2 commits
  33. 22 Oct, 2015 1 commit