This file is indexed.

/usr/share/psychtoolbox-3/PsychDemos/MandelbrotDemo.m is in psychtoolbox-3-common 3.0.14.20170103+git6-g605ff5c.dfsg1-1build1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
function MandelbrotDemo
% MandelbrotDemo -- GPU visualization of the fractal Mandelbrot set.
%
% This demo illustrates the use of "procedural textures" with Psychtoolbox.
% A procedural texture is a texture that is not directly represented by an image
% matrix in memory, but the image content of the texture is generated on
% the fly during drawing of the texture by means of a small algorithm - a
% shader. The shader implements some mathematical formula or model which is
% evaluated to generate image content, or it reads content of a data
% matrix and transforms it into a picture. Psychtoolbox supports both,
% purely virtual textures of unlimited size that are purely algorithmically
% generated, and hybrid textures where an algorithm transforms the textures
% content into something to be drawn.
%
% The algorithm has to be implemented by a GLSL shader program - a vertex shader,
% primitive shader, fragment shader or any combination of them. The shader
% program is read from a file, compiled and then attached to the texture on
% texture creation time. Procedural textures only work with graphics
% hardware that has sufficiently advanced support for at least hardware
% fragment shaders.
%
% This demo implements the mathematical formula for visualization of the
% famous fractal Mandelbrot set in a fragment shader. The shader gets
% attached to a purely virtual texture. The texture is drawn via the
% standard Screen('DrawTexture') command -- your graphics processor
% generates the image content of the Mandelbrot set on the fly during
% drawing of the texture via evaluation of the mandelbrot formula.
% Selecting a subregion (the sourceRect parameter of 'DrawTexture') allows
% to zoom into a specific subregion of the Mandelbrot set.
%
% The implementation uses up to 150 iterations of the equation for each
% drawn pixel, so it may be slow on old hardware.
%
% In the demo, use gentle mouse movements to scroll around in the set and
% the left- right- mouse button to zoom into/out of the set. Press any key
% on the keyboard to exit the demo.
%
% Wikipedia http://www.wikipedia.org has a nice explanation of the
% Mandelbrot set under the search term "Mandelbrot set".
%
% The shader used for this demo is part of the "Orange book" - The guide to
% the OpenGL Shading language. The code is copyright 3DLabs. See the
% 3DLabs-License.txt file in the PsychDemos/OpenGLDemos/GLSLDemoShaders/
% subfolder for the license.

% History:
% 19.05.2007 Written (MK)

% Acquire a handle to OpenGL, so we can use OpenGL commands in our code:
global GL;

% Make sure this is running on OpenGL Psychtoolbox:
AssertOpenGL;

% Choose screen with maximum id - the secondary display:
screenid = max(Screen('Screens'));

% Open a fullscreen onscreen window on that display, choose a background
% color of 128 = gray with 50% max intensity:
[win winRect]= Screen('OpenWindow', screenid, 128);

% Query width and height of window:
[tw, th] = Screen('WindowSize', win);

% Load the shader program from source file 'MandelbrotShader.frag.txt',
% compile it and get a handle to the GLSL program:
MandelbrotShader = LoadGLSLProgramFromFiles([ PsychtoolboxRoot 'PsychDemos/MandelbrotShader'], 1);

% Create purely virtual procedural texture. The texture has a width x
% height x depth of 1 x 1 x 1 texels (the only interesting area in the
% mandelbrot complex number plane). Attach the GLGL MandelbrotShader
% program which defines the texture algorithmically:
mandelbrottex = Screen('SetOpenGLTexture', win, [], 0, GL.TEXTURE_RECTANGLE_EXT, 1, 1, 1, MandelbrotShader);

% Activate the shader and setup some fractal parameters:
glUseProgram(MandelbrotShader);
glUniform2f(glGetUniformLocation(MandelbrotShader, 'center'), -0.57, -0.01);
glUniform1f(glGetUniformLocation(MandelbrotShader, 'zoom'), 1);
% Shader set up, deactivate it:
glUseProgram(0);

% Set good start values for zoom factor and position:
zoom = 1;
srcRect = CenterRectOnPoint([-0.5 -0.5 0.5 0.5]/zoom, 0.5, 0.5);
Screen('DrawTexture', win, mandelbrottex, srcRect, winRect);

% Position the mouse cursor at the center of the screen:
SetMouse(tw/2, th/2, win);

% Show some usage info text:
Screen('TextSize', win, 24);
Screen('TextStyle', win, 1);
DrawFormattedText(win, 'MandelbrotDemo\n\nGently move the mouse cursor to navigate in the Mandelbrot-Plane\nPress Left-/Right- mouse button to zoom in/out\n\nPress any key to quit\n\nPress mouse button to start.', 'center', 'center', [255 255 0]);

% Initial flip to show help text and sync us to the retrace:
Screen('Flip', win);

% Wait for mouse click to start animation loop:
GetClicks(win);

% Sync us to retrace and flip:
vbl = Screen('Flip', win);
ts = vbl;
count = 0;

% Animation loop. Runs until any key is pressed:
while ~KbCheck
    % Increment framecounter:
    count = count + 1;
    
    % Query mouse position and state:
    [x y buttons] = GetMouse(win);

    % Left mouse button pressed?
    if buttons(1)
        % Increase zoom factor:
        zoom = zoom + 0.01 * zoom;
    end

    % Right mouse button pressed?
    if buttons(2)
        % Decrease zoom factor:
        zoom = zoom - 0.01 * zoom;
    end

    % Map the current mouse pointer position to the area of the texture
    % that should be drawn - the area of interest in the complex number
    % plane:
    xt = (x/tw) * RectWidth(srcRect) + srcRect(RectLeft);
    yt = (y/th) * RectHeight(srcRect) + srcRect(RectTop);
    srcRect = CenterRectOnPoint([-0.5 -0.5 0.5 0.5]/zoom, xt, yt);
    
    % Draw the selected subregion srcRect of the Mandelbrot texture and
    % zoom it up to cover the whole window area winRect:
    Screen('DrawTexture', win, mandelbrottex, srcRect, winRect);

    % Show updated image via buffer flip at next retrace:
    vbl = Screen('Flip', win, vbl+0.005);
end

% Done. Print some runtime stats:
avgfps = count / (GetSecs - ts)

% Close the window, release all ressources:
sca;

% Done.