Luxophia

1
#version 430
2

3
#extension GL_ARB_compute_variable_group_size : enable
4

5
//layout( local_size_variable ) in;
6
  layout( local_size_x = 10,
7
          local_size_y = 10,
8
          local_size_z =  1   ) in;
9

10
//------------------------------------------------------------------------------
11
  const ivec3 _WorkGrupsN = ivec3( gl_NumWorkGroups );
12

13
//const ivec3 _WorkItemsN = ivec3( gl_LocalGroupSizeARB );
14
  const ivec3 _WorkItemsN = ivec3( gl_WorkGroupSize     );
15

16
  const ivec3 _WorksN     = _WorkGrupsN * _WorkItemsN;
17

18
  const ivec3 _WorkID     = ivec3( gl_GlobalInvocationID );
19

20

21
struct TDoubleC
22
{
23
    double R;
24
    double I;
25
};
26

27
//------------------------------------------------------------------------------
28

29
TDoubleC Add( TDoubleC A, TDoubleC B )
30
{
31
    TDoubleC Result;
32

33
    Result.R = A.R + B.R;
34
    Result.I = A.I + B.I;
35

36
    return Result;
37
}
38

39
TDoubleC Sub( TDoubleC A, TDoubleC B )
40
{
41
    TDoubleC Result;
42

43
    Result.R = A.R - B.R;
44
    Result.I = A.I - B.I;
45

46
    return Result;
47
}
48

49
TDoubleC Mul( TDoubleC A, TDoubleC B )
50
{
51
    TDoubleC Result;
52

53
    Result.R = A.R * B.R - A.I * B.I;
54
    Result.I = A.R * B.I + A.I * B.R;
55

56
    return Result;
57
}
58

59
TDoubleC Pow2( TDoubleC C )
60
{
61
    return Mul( C, C );
62
}
63

64
double Abs( TDoubleC C )
65
{
66
    return sqrt( C.R * C.R + C.I * C.I );
67
}
68

69
//----------------------------------------------------------------------------
70

71
struct TAreaC
72
{
73
    TDoubleC Min;
74
    TDoubleC Max;
75
};
76

77
//----------------------------------------------------------------------------
78

79
layout( std430 ) buffer TBuffer
80
{
81
    TAreaC _RangeC;
82
};
83

84
writeonly uniform image2D _Imager;
85

86
uniform sampler1D _Textur;
87

88
//----------------------------------------------------------------------------
89

90
TDoubleC ScreenToComplex( ivec2 S )
91
{
92
    TDoubleC Result;
93

94
    Result.R = ( _RangeC.Max.R - _RangeC.Min.R ) * ( S.x + 0.5 ) / _WorksN.x + _RangeC.Min.R;
95
    Result.I = ( _RangeC.Min.I - _RangeC.Max.I ) * ( S.y + 0.5 ) / _WorksN.y + _RangeC.Max.I;
96

97
    return Result;
98
}
99

100
vec4 ComplexToColor( TDoubleC C )
101
{
102
    TDoubleC Z = TDoubleC( 0, 0 );
103

104
    for ( int N = 1; N < 500; N++ )
105
    {
106
        Z = Add( Pow2( Z ), C );
107

108
        if ( Abs( Z ) > 2 ) return texture( _Textur, N / 500.0 );
109
    }
110

111
    return texture( _Textur, 1 );
112
}
113

114
//----------------------------------------------------------------------------
115

116
void main()
117
{
118
  TDoubleC C = ScreenToComplex( _WorkID.xy );
119

120
  vec4 L = ComplexToColor( C );
121

122
  imageStore( _Imager, _WorkID.xy, L );
123
}
124

125
//----------------------------------------------------------------------------
126