python-microscopy 25.11.20__cp313-cp313-win_amd64.whl

PYME/LMVis/shader_programs/PointSpriteShaderProgram.py

@@ -0,0 +1,163 @@
+#!/usr/bin/python
+
+# PointSpriteShaderProgram.py
+#
+# Copyright Michael Graff
+#   graff@hm.edu
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+import os
+
+from OpenGL.GL import *
+from PYME.LMVis.shader_programs.GLProgram import GLProgram
+from PYME.LMVis.shader_programs.shader_program import ShaderProgram
+#from PYME.LMVis.gl_texture import GaussTexture
+
+import numpy as np
+from PYME.LMVis.rendGauss import gaussKernel
+
+import warnings
+
+class GaussTexture:
+
+    # specific texture id of this texture
+    _texture_id = None
+
+    def __init__(self):
+        pass
+
+    def bind_texture(self, uniform_location):
+        """
+        This methods binds exactly one texture.
+        Parameters
+        ----------
+        uniform_location: int, defines the uniform location, use shader_program.get_uniform_location
+
+        Returns
+        -------
+
+        """
+        glActiveTexture(GL_TEXTURE0)
+        if self._texture_id is None:
+            self.load_texture()
+        else:
+            glBindTexture(GL_TEXTURE_2D, self._texture_id)
+
+        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
+        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
+        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT)
+        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT)
+        glUniform1i(uniform_location, 0)
+
+    def create_texture(self, size=31, sigma=5, normalize_sum=False):
+        """
+        This method create a gauss kernel texture and stores it on the graphics card.
+        The max amplitude of the kernel is 1.
+        Parameters
+        ----------
+        size size of the kernel
+        sigma of the kernel
+
+        Returns
+        -------
+        size correction factor is a factor that should be multiplied on the texture size.
+        That way sprites don't appear smaller than opaque dots
+        """
+        data = gaussKernel(size, sigma)
+        # index of the first element that is bigger than 0.5
+        index = next(x[0] for x in enumerate(data[size // 2, :]) if x[1] > 0.5)
+        size_correction_factor = (float(size) / 2) / float(size // 2 - index)
+
+        if normalize_sum:
+            data /= data.sum()
+
+        self._data = data
+        return size_correction_factor
+
+    def load_texture(self):
+        size = self._data.shape[0]
+        self._texture_id = glGenTextures(1)
+        glBindTexture(GL_TEXTURE_2D, self._texture_id)
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, size, size, 0, GL_RED, GL_FLOAT, np.float16(self._data))
+
+    def delete_texture(self):
+        glDeleteTextures(1, self._texture_id)
+
+    @staticmethod
+    def enable_texture_2d():
+        glEnable(GL_TEXTURE_2D)
+
+    @staticmethod
+    def disable_texture_2d():
+        glDisable(GL_TEXTURE_2D)
+
+
+
+class PointSpriteShaderProgram(GLProgram):
+    #    This attribute holds an instance of a texture class
+    _texture = None
+    #    This is the uniform location to pass to the fragment shader to locate the texture
+    #_uniform_tex_2d_id = 0
+
+    def __init__(self, **kwargs):
+        GLProgram.__init__(self, vs_filename='pointsprites_vs.glsl', fs_filename='pointsprites_fs.glsl', **kwargs)
+        self._texture = GaussTexture()
+        self.size_factor = self._texture.create_texture()
+        
+
+    def get_size_factor(self):
+        warnings.warn("use size_factor attribute instead", DeprecationWarning)
+        return self.size_factor
+
+    def __enter__(self):
+        self._old_prog = glGetInteger(GL_CURRENT_PROGRAM)
+        self.get_shader_program().use()
+        self.set_clipping_uniforms()
+        
+        try:
+            glEnable(GL_POINT_SPRITE)
+        except:
+            # deprecated for core profile
+            pass
+        glEnable(GL_PROGRAM_POINT_SIZE)
+        glDisable(GL_DEPTH_TEST)
+        glEnable(GL_BLEND)
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE)
+        #glBlendEquation(GL_FUNC_ADD)
+        #self._texture.enable_texture_2d()
+        self._texture.bind_texture(self._shader_program.get_uniform_location(b'tex2D'))
+
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        glUseProgram(self._old_prog)
+        glDisable(GL_BLEND)
+        glDisable(GL_PROGRAM_POINT_SIZE)
+        try:
+            glDisable(GL_POINT_SPRITE)
+        except:
+            # deprecated for core profile
+            pass
+        glEnable(GL_DEPTH_TEST)
+
+    def __del__(self):
+        # self._texture.delete_texture()
+        pass
+
+class BigPointSpriteShaderProgram(PointSpriteShaderProgram):
+    def __init__(self, **kwargs):
+        GLProgram.__init__(self, vs_filename='default_vs.glsl', fs_filename='bigpointsprites_fs.glsl', gs_filename='bigpoints_gs.glsl', **kwargs)
+        self._texture = GaussTexture()
+        self.size_factor = self._texture.create_texture()

PYME/LMVis/shader_programs/ShaderProgramFactory.py

@@ -0,0 +1,54 @@
+#!/usr/bin/python
+
+# ShaderProgramFactory.py
+#
+# Copyright Michael Graff
+#   graff@hm.edu
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+import logging
+logger = logging.getLogger(__name__)
+
+class ShaderProgramFactory(object):
+    def __init__(self):
+        pass
+
+    _programs = {}
+
+    @staticmethod
+    def get_program(class_name, context=None, window=None):
+        """
+
+        Parameters
+        ----------
+        class_name is the real class of the ShaderProgram
+
+        Returns
+        -------
+        object of the given class. If there's already an existing one. That one is returned.
+        """
+        existing_program = ShaderProgramFactory._programs.get((class_name, context))
+        if existing_program:
+            return existing_program
+        else:
+            if context and window:
+                context.SetCurrent(window)
+            
+            #print("Creating new shader program - max glsl version: {}".format(window.glsl_version))
+            new_program = class_name(max_glsl_version=getattr(window,'glsl_version', '120'))
+            
+            ShaderProgramFactory._programs[(class_name, context)] = new_program
+            logger.debug("New shader program created: {}".format(class_name))
+            return new_program

PYME/LMVis/shader_programs/TesselShaderProgram.py

@@ -0,0 +1,47 @@
+#!/usr/bin/python
+
+# WireFrameShaderProgram.py
+#
+# Copyright Michael Graff
+#   graff@hm.edu
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+import os
+
+from PYME.LMVis.shader_programs.GLProgram import GLProgram
+from OpenGL.GL import GL_VERTEX_SHADER, GL_FRAGMENT_SHADER, glPolygonMode, \
+    GL_FRONT_AND_BACK, GL_LINE, GL_FILL, glUseProgram, GL_BLEND,glDisable, glEnable, glDepthMask, GL_TRUE, GL_FALSE, \
+    GL_DEPTH_TEST, glBlendFunc, GL_SRC_ALPHA, GL_ONE, glGetInteger, GL_CURRENT_PROGRAM
+from PYME.LMVis.shader_programs.shader_program import ShaderProgram
+
+
+class TesselShaderProgram(GLProgram):
+    def __enter__(self):
+        self._old_prog = glGetInteger(GL_CURRENT_PROGRAM)
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE)
+        glEnable(GL_BLEND)
+        glDepthMask(GL_TRUE)
+        glDisable(GL_DEPTH_TEST)
+        #glDepthFunc(GL_LEQUAL)
+        #glEnable(GL_POINT_SMOOTH)
+        self.get_shader_program().use()
+        self.set_clipping_uniforms()
+        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
+
+        return self
+
+    def __init__(self, **kwargs):
+        GLProgram.__init__(self, vs_filename='default_vs.glsl', fs_filename='tessel_fs.glsl', **kwargs)
+        

PYME/LMVis/shader_programs/WireFrameShaderProgram.py

@@ -0,0 +1,50 @@
+#!/usr/bin/python
+
+# WireFrameShaderProgram.py
+#
+# Copyright Michael Graff
+#   graff@hm.edu
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+import os
+
+from PYME.LMVis.shader_programs.GLProgram import GLProgram
+
+from OpenGL.GL import GL_VERTEX_SHADER, GL_FRAGMENT_SHADER, glPolygonMode, \
+    GL_FRONT_AND_BACK, GL_LINE, glUseProgram, GL_BLEND,glDisable, glEnable, glDepthMask, GL_TRUE, GL_FALSE, GL_DEPTH_TEST, \
+    glBlendFunc, GL_SRC_ALPHA, GL_ONE, glGetInteger, GL_CURRENT_PROGRAM
+from PYME.LMVis.shader_programs.shader_program import ShaderProgram
+
+
+class WireFrameShaderProgram(GLProgram):
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        glUseProgram(self._old_prog)
+        pass
+
+    def __enter__(self):
+        self._old_prog = glGetInteger(GL_CURRENT_PROGRAM)
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE)
+        glEnable(GL_BLEND)
+        glDepthMask(GL_TRUE)
+        glDisable(GL_DEPTH_TEST)
+        self.get_shader_program().use()
+        self.set_clipping_uniforms()
+        glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)
+
+        return self
+
+    def __init__(self, **kwargs):
+        GLProgram.__init__(self, vs_filename='default_vs.glsl', fs_filename='default_fs.glsl', **kwargs)
+        

PYME/LMVis/shader_programs/__init__.py

@@ -0,0 +1,20 @@
+#!/usr/bin/python
+
+# __init__.py
+#
+# Copyright Michael Graff
+#   graff@hm.edu
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#

PYME/LMVis/shader_programs/oit_compositor.py

@@ -0,0 +1,23 @@
+import os
+from PYME.LMVis.shader_programs.GLProgram import GLProgram
+from OpenGL.GL import *
+from PYME.LMVis.shader_programs.shader_program import ShaderProgram
+
+class OITCompositorProgram(GLProgram):
+    def __init__(self, **kwargs):
+        GLProgram.__init__(self, **kwargs)
+        shader_path = os.path.join(os.path.dirname(__file__), "shaders")
+        shader_program = ShaderProgram(shader_path, **kwargs)
+        shader_program.add_shader("compose_vs.glsl", GL_VERTEX_SHADER)
+        shader_program.add_shader("compose_fs.glsl", GL_FRAGMENT_SHADER)
+        shader_program.link()
+        self.set_shader_program(shader_program)
+    
+    def __enter__(self):
+        self._old_prog = glGetInteger(GL_CURRENT_PROGRAM)
+        self.get_shader_program().use()
+        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        glUseProgram(self._old_prog)

PYME/LMVis/shader_programs/shader_loader.py

@@ -0,0 +1,84 @@
+#!/usr/bin/python
+
+##################
+# gl_shaderLoader.py
+#
+# Copyright Michael Graff
+# graff@hm.edu
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+##################
+
+import os
+
+
+class ShaderLoader(object):
+    """
+    This class is used to load shader source code and deliver it to programs that need it.
+
+
+    It could be used to read any text based file. But this would be confusing and should't be done.
+    """
+
+    # The source code of the most frequent shader that has been read using this instance.
+    # Don't access it directly, but use the given getter
+    _code = 0
+
+    def __init__(self):
+        pass
+
+    def read_file(self, path):
+        """
+        Read a shader source file.
+        :param path: the directory and the filename as the shader is saved on the disk
+                     it can be relative or absolute
+        :return: a string representing the source code of the shader
+        """
+        try:
+            with open(path, 'r') as f:
+                self._code = f.read()
+            return self._code
+        except IOError as e:
+            message = "File {} could not be read properly in folder: {}".format(path, os.getcwd())
+            raise GLShaderLoadException(e.errno, e.strerror, message)
+
+    def read_file_with_path(self, path, file_name):
+        """
+        Read a shader source file.
+        :param path: the directory on the disk, including the last '/'
+                     it can be relative or absolute
+        :param file_name:  the filename of the shader source
+        :return: a string representing the source code of the shader
+        """
+        return self.read_file(os.path.join(path, file_name))
+
+    def get_code(self):
+        return self._code
+
+    def __del__(self):
+        self._code = None
+
+
+class GLShaderLoadException(Exception):
+    """
+    This class is used if an error in the ShaderLoader occurs
+    You usually only pass the text message to the constructor and raise the exception
+    """
+    def __init__(self, *args, **kwargs):
+        Exception.__init__(self, *args, **kwargs)
+
+if __name__ == '__main__':
+    s = ShaderLoader()
+    print(s.read_file_with_path("./shaders/", "pointsprites_fs.glsl"))

PYME/LMVis/shader_programs/shader_program.py

@@ -0,0 +1,168 @@
+#!/usr/bin/python
+
+##################
+# ShaderProgram.py
+#
+# Copyright Michael Graff
+# graff@hm.edu
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+##################
+
+from OpenGL.GL import *
+
+from PYME.LMVis.shader_programs.shader_loader import GLShaderLoadException
+
+
+class ShaderProgram(object):
+    """
+    This class handles all  OpenGl-PROGRAM related stuff
+
+    This includes loading and adding shaders, compiling them
+    and handling or raising exceptions.
+
+    """
+
+#   that's the actual OpenGL program handle
+    _program = 0
+#   that's the path where the shader files are saved
+    _shader_path = None
+
+    _shaders = set()
+
+    def __init__(self, shader_path="./shaders/", max_glsl_version='120'):
+        """
+
+        :param shader_path: the folder that contains the shader sources
+                            ending with a '/'
+                            It can be relative or absolute.
+        :raises GLProgramException if glUseProgram is not successful
+        """
+        if not glUseProgram:
+            raise GLProgramException('Missing Shader Objects!')
+        self._shader_path = shader_path
+        self._max_glsl_version = max_glsl_version
+        self._program = glCreateProgram()
+
+        self._vs_glsl_version = 'None'
+        
+        if self._program == 0:
+            raise RuntimeError('glCreateProgram failed')
+
+    def add_shader(self, shader_name, shader_type):
+        """
+        This method adds a new shader module to the program.
+
+        :param shader_name: the filename of the shader that should be loaded
+                            keep in mind that the shader_path was set in __init__
+        :param shader_type: defines the stage the shader should be added
+                            e.g. GL_VERTEX_SHADER, GL_FRAGMENT_SHADER
+        :return: nothing
+
+        :raises: GLShaderLoadException if the shader could not be loaded
+        :raises: GLProgramException if the shader could not be compiled
+
+        """
+        shader = glCreateShader(shader_type)
+        code, vers = read_shader(shader_name, self._shader_path, max_glsl_version=self._max_glsl_version)
+        glShaderSource(shader, code)
+        glCompileShader(shader)
+        is_compiled = glGetShaderiv(shader, GL_COMPILE_STATUS)
+        if is_compiled != 1:
+            error_log = glGetShaderInfoLog(shader)
+            exception = GLProgramException("Shader " + shader_name + " didn't compile correctly", error_log)
+            glDeleteShader(shader)
+            raise exception
+        glAttachShader(self._program, shader)
+        if shader_type == GL_VERTEX_SHADER:
+            # store the version of the vertex shader (so we can see if we need to set modelview matrix etc ...)
+            self._vs_glsl_version = vers
+
+        self._shaders.add(shader)
+
+    # def get_program(self):
+    #     """
+    #     Returns the real handle
+    #     :return: the real handle to the OpenGL-program used by the OpenGL-Context
+    #     """
+    #     return self._program
+
+    def link(self):
+        glLinkProgram(self._program)
+
+    def get_uniform_location(self, uniform_name):
+        return glGetUniformLocation(self._program, uniform_name)
+
+    def use(self):
+        try:
+            glUseProgram(self._program)
+        except GLError:
+            exception = GLProgramException(glGetProgramInfoLog(self._program))
+            raise exception
+
+    def __del__(self):
+        # shaders seem to have been deleted already, since it throws errors
+        # for shader in self._shaders:
+        #     glDeleteShader(shader)
+        # glDeleteProgram(self._program)
+        pass
+
+import re
+import os
+vers_re = re.compile('#version\s+(\d+)\s*')
+
+def read_shader(shader_name, path, max_glsl_version='120'):
+    """
+    This method reads a given shader within a given file path
+
+    :param shader_name: the name of the shader file
+    :param path: the path where the shader is stored on disk
+    :return: a string representing the shader
+    :raises: GLShaderLoadException if the shader could not be loaded
+    """
+    import re
+    fn = os.path.join(path, shader_name)
+    with open(fn, 'r') as f:
+        code = f.read()
+
+    # we can store multiple versions of the same shader in one file
+    # demarcarted by their initial #version statements
+    shaders = ['#version' + s for s in code.split('#version') if not len(s) == 0]
+    #print(shaders)
+    #parse the version statements to get an actual version number for each shader
+    shader_versions = [vers_re.match(s.split('\n')[0]).group(1) for s in shaders]
+    #print(shader_versions)
+
+    #find the highest version number that is less than or equal to the max_glsl_version
+    max_version = '100'
+    max_shader = None
+    for s, v in zip(shaders, shader_versions):
+        if v <= max_glsl_version and v > max_version:
+            max_version = v
+            max_shader = s
+
+    if max_shader is None:
+        raise GLShaderLoadException(0, 'No shader found with version <= %s' % max_glsl_version, 'No shader found with version <= %s' % max_glsl_version)    
+    
+    return max_shader, max_version
+
+
+class GLProgramException(IOError):
+    """
+    This class is used if an error in the OpenGLProgramHandler occurs
+    You usually only pass the text message to the constructor and raise the exception
+    """
+    def __init__(self, *args, **kwargs):
+        Exception.__init__(self, *args, **kwargs)

PYME/LMVis/shader_programs/shaders/bigflatpoints_fs.glsl

@@ -0,0 +1,16 @@
+#version 330 core
+// Like the flatpoints shader, but using texture coordinates rather than point coordinates
+in float visibility;
+in vec4 frontColor;
+in vec2 texCoord;
+
+layout(location = 0) out vec4 FragColor;
+
+void main() {
+    //gl_FragColor = vec4(1.0, 1.0, 0.0, 1.0);
+    if (visibility < .5) discard;
+
+    vec2 circ_coord = 2.0 * texCoord - 1.0;
+    if (dot(circ_coord, circ_coord) > 1) discard;
+    FragColor = frontColor;
+}

PYME/LMVis/shader_programs/shaders/bigpoints_gs.glsl

@@ -0,0 +1,40 @@
+#version 330 core
+// convert points to quads by using a geometry shader
+
+uniform float point_size_vp;
+uniform vec2 viewport_size;
+
+layout (points) in;
+layout (triangle_strip, max_vertices = 4) out;
+
+in vec4 FrontColor[];
+in float vis[];
+
+out vec4 frontColor;
+out vec2 texCoord;
+out float visibility;
+
+void main(){
+    float half_size = point_size_vp / 2.0;
+    float aspect_ratio = viewport_size.x / viewport_size.y;
+    vec4 position = gl_in[0].gl_Position;
+
+    // pass through colour and visibility
+    frontColor = FrontColor[0];
+    visibility = vis[0];
+
+    gl_Position = position + vec4(-half_size, -half_size*aspect_ratio, 0.0, 0.0);    // 1:bottom-left
+    texCoord = vec2(0.0, 0.0);
+    EmitVertex();   
+    gl_Position = position + vec4( half_size, -half_size*aspect_ratio, 0.0, 0.0);    // 2:bottom-right
+    texCoord = vec2(1.0, 0.0);
+    EmitVertex();
+    gl_Position = position + vec4(-half_size,  half_size*aspect_ratio, 0.0, 0.0);    // 3:top-left
+    texCoord = vec2(0.0, 1.0);
+    EmitVertex();
+    gl_Position = position + vec4( half_size,  half_size*aspect_ratio, 0.0, 0.0);    // 4:top-right
+    texCoord = vec2(1.0, 1.0);
+    EmitVertex();
+    EndPrimitive();
+
+}

PYME/LMVis/shader_programs/shaders/bigpointsprites_fs.glsl

@@ -0,0 +1,20 @@
+#version 330
+
+// This fragmentshader takes the given color and displays it.
+// It's transparency is determined by a submitted texture. That way the brightness is decreasing with the distance to the \
+// center of the point.
+
+uniform sampler2D tex2D;
+
+in vec4 frontColor;
+in float visibility;
+in vec2 texCoord;
+
+layout (location = 0) out vec4 fragColor;
+
+void main()
+{
+    if (visibility <0.5) discard;
+    float alpha = frontColor.a * texture(tex2D, texCoord).x;
+    fragColor = vec4(frontColor.xyz, alpha);
+}