Welcome to Fractal Forums

1> qmake
2> make
3> make install

		void AnimationController::jumpToKeyFrame(QListWidgetItem *it) {
		  int kfr = keyFrameList->row(it);
		  float t = (1.0/animationSettings.getKeyFrameCount());
		  int fr = (t*kfr)*(0.5+animationSettings.totalFrames());
		  animationSettings.setFrame(fr);
		};

          gl_FragDepth =  gl_FragCoord.z / gl_FragCoord.w;
	}
	else {
		hitColor = backColor;
		hitColor +=Glow.xyz*stepFactor* Glow.w*(1.0-shadowStrength);
          gl_FragDepth = 1.0;
	
	}

float zNear = 0.001;
float adt = MaxDistance / (MaxDistance - zNear);
float bdt = MaxDistance * zNear / (zNear - MaxDistance);
gl_FragDepth = (adt + bdt / clamp(totalDist/length(dir), zNear, MaxDistance));

glDisable( GL_DEPTH_TEST ); // disables testing but not writing

glDepthMask(GL_FALSE); // disables writing to depth buffer but not testing
				glRectf(-1,-1,1,1);
glDepthMask(GL_TRUE); // we don't want the rect to obscure anything in the depth buffer

float zNear = 0.001;
float adt = MaxDistance / (MaxDistance - zNear);
float bdt = MaxDistance * zNear / (zNear - MaxDistance);
gl_FragDepth = (adt + bdt / clamp(totalDist/length(dir), zNear, MaxDistance));

/// Power:SineCurve:43:1.0:8.96:40:200

#group Raytracer
// Sets focal plane to Target location 
uniform bool AutoFocus; checkbox[false]

#include "DE-Raytracer.frag"

drawingState != Animation && !isContinuous()

uniform float Parameter; slider[-0.01,0,0.01]

uniform float Parameter1; slider[-0.01,0,0.01]
uniform float Parameter2; slider[-0.01,0,0.01]
uniform float Parameter3; slider[-0.01,0,0.01]

/// Parameter1:InQuad:1:0.01:0:1:88:0.3:1:1.7
/// Parameter2:OutBounce:38:0:0.01:137:216:0.3:1:1.7
/// Parameter3:OutCurve:42:0:-0.01:252:356:0.3:1:1.7

float Parameter=Parameter1+Parameter2+Parameter3 ;

#info Mandelbulb Distance Estimator
#define providesInit
#include "DE-Raytracer.frag"
#include "MathUtils.frag"
#group Mandelbulb

// Number of fractal iterations.
uniform int Iterations;  slider[0,9,100]

// Number of color iterations.
uniform int ColorIterations;  slider[0,9,100]

// Mandelbulb exponent (8 is standard)
uniform float Power; slider[0,8,16]

// Bailout radius
uniform float Bailout; slider[0,5,30]

// Alternate is slightly different, but looks more like a Mandelbrot for Power=2
uniform bool AlternateVersion; checkbox[false]

uniform vec3 RotVector; slider[(0,0,0),(1,1,1),(1,1,1)]

uniform float RotAngle; slider[0.00,0,180]

mat3 rot;
uniform float time;
void init() {
	 rot = rotationMatrix3(normalize(RotVector), RotAngle);
       float dummy = time*10.0;
}

// This is my power function, based on the standard spherical coordinates as defined here:
// http://en.wikipedia.org/wiki/Spherical_coordinate_system
//
// It seems to be similar to the one Quilez uses:
// http://www.iquilezles.org/www/articles/mandelbulb/mandelbulb.htm
//
// Notice the north and south poles are different here.
void powN1(inout vec3 z, float r, inout float dr) {
	// extract polar coordinates
	float theta = acos(z.z/r);
	float phi = atan(z.y,z.x);
	dr =  pow( r, Power-1.0)*Power*dr + 1.0;
	
	// scale and rotate the point
	float zr = pow( r,Power);
	theta = theta*Power;
	phi = phi*Power;
	
	// convert back to cartesian coordinates
	z = zr*vec3(sin(theta)*cos(phi), sin(phi)*sin(theta), cos(theta));
}

// This is a power function taken from the implementation by Enforcer:
// http://www.fractalforums.com/mandelbulb-implementation/realtime-renderingoptimisations/
//
// I cannot follow its derivation from spherical coordinates,
// but it does give a nice mandelbrot like object for Power=2
void powN2(inout vec3 z, float zr0, inout float dr) {
	float zo0 = asin( z.z/zr0 );
	float zi0 = atan( z.y,z.x );
	float zr = pow( zr0, Power-1.0 );
	float zo = zo0 * Power;
	float zi = zi0 * Power;
	dr = zr*dr*Power + 1.0;
	zr *= zr0;
	z  = zr*vec3( cos(zo)*cos(zi), cos(zo)*sin(zi), sin(zo) );
}



uniform bool Julia; checkbox[false]
uniform vec3 JuliaC; slider[(-2,-2,-2),(0,0,0),(2,2,2)]

// Compute the distance from `pos` to the Mandelbox.
float DE(vec3 pos) {
	vec3 z=pos;
	float r;
	float dr=1.0;
	int i=0;
	r=length(z);
	while(r<Bailout && (i<Iterations)) {
		if (AlternateVersion) {
			powN2(z,r,dr);
		} else {
			powN1(z,r,dr);
		}
		z+=(Julia ? JuliaC : pos);
		r=length(z);
		z*=rot;
		if (i<ColorIterations) orbitTrap = min(orbitTrap, abs(vec4(z.x,z.y,z.z,r*r)));
		i++;
	}
//	if ((type==1) && r<Bailout) return 0.0;
	return 0.5*log(r)*r/dr;
	/*
	Use this code for some nice intersections (Power=2)
	float a =  max(0.5*log(r)*r/dr, abs(pos.y));
	float b = 1000;
	if (pos.y>0)  b = 0.5*log(r)*r/dr;
	return min(min(a, b),
		max(0.5*log(r)*r/dr, abs(pos.z)));
	*/
}

#preset Default
FOV = 0.62536
Eye = 1.65826,-1.22975,0.277736
Target = -5.2432,4.25801,-0.607125
Up = 0.401286,0.369883,-0.83588
EquiRectangular = false
FocalPlane = 1
Aperture = 0
Gamma = 2.08335
ToneMapping = 3
Exposure = 0.6522
Brightness = 1
Contrast = 1
Saturation = 1
GaussianWeight = 1
AntiAliasScale = 2
Detail = -2.84956
DetailAO = -1.35716
FudgeFactor = 1
MaxRaySteps = 164
Dither = 0.51754
NormalBackStep = 1
AO = 0,0,0,0.85185
Specular = 1.6456
SpecularExp = 16.364
SpecularMax = 10
SpotLight = 1,1,1,1
SpotLightDir = 0.63626,0.5
CamLight = 1,1,1,1.53846
CamLightMin = 0.12121
Glow = 1,1,1,0.43836
GlowMax = 52
Fog = 0
HardShadow = 0.35385
ShadowSoft = 12.5806
Reflection = 0
DebugSun = false
BaseColor = 1,1,1
OrbitStrength = 0.14286
X = 1,1,1,1
Y = 0.345098,0.666667,0,0.02912
Z = 1,0.666667,0,1
R = 0.0784314,1,0.941176,-0.0194
BackgroundColor = 0.607843,0.866667,0.560784
GradientBackground = 0.3261
CycleColors = false
Cycles = 4.04901
EnableFloor = false
FloorNormal = 0,0,0
FloorHeight = 0
FloorColor = 1,1,1
Iterations = 12
ColorIterations = 8
Power = 8
Bailout = 6.279
AlternateVersion = true
RotVector = 1,1,1
RotAngle = 0
Julia = false
JuliaC = 0,0,0
#endpreset

#preset Octobulb
FOV = 0.62536
Eye = -0.184126,0.843469,1.32991
Target = 1.48674,-5.55709,-4.56665
Up = -0.240056,-0.718624,0.652651
AntiAlias = 1
Detail = -2.47786
DetailAO = -0.21074
FudgeFactor = 1
MaxRaySteps = 164
BoundingSphere = 2
Dither = 0.5
AO = 0,0,0,0.7
Specular = 1
SpecularExp = 27.082
SpotLight = 1,1,1,0.94565
SpotLightDir = 0.5619,0.18096
CamLight = 1,1,1,0.23656
CamLightMin = 0.15151
Glow = 0.415686,1,0.101961,0.18421
Fog = 0.60402
HardShadow = 0.72308
Reflection = 0
BaseColor = 1,1,1
OrbitStrength = 0.62376
X = 0.411765,0.6,0.560784,-0.37008
Y = 0.666667,0.666667,0.498039,0.86886
Z = 0.666667,0.333333,1,-0.25984
R = 0.4,0.7,1,0.36508
BackgroundColor = 0.666667,0.666667,0.498039
GradientBackground = 0.5
CycleColors = true
Cycles = 7.03524
FloorNormal = 0,0,0
FloorHeight = 0
FloorColor = 1,1,1
Iterations = 14
ColorIterations = 6
Power = 8.18304
Bailout = 6.279
AlternateVersion = true
RotVector = 1,0,0
RotAngle = 77.8374
#endpreset


#preset KeyFrame.001
FOV = 0.62536
Eye = 34.2122,-27.1153,4.45159
Target = 27.3107,-21.6275,3.56673
Up = 0.401286,0.369883,-0.83588
#endpreset

#preset KeyFrame.002
FOV = 0.62536
Eye = 2.2424,-1.69419,0.352655
Target = -4.6591,3.79361,-0.532205
Up = 0.401286,0.369883,-0.83588
#endpreset

#preset KeyFrame.003
FOV = 0.62536
Eye = 0.808919,-0.554342,0.168864
Target = -6.09258,4.93346,-0.715996
Up = 0.401286,0.369883,-0.83588
#endpreset

#preset KeyFrame.001
FOV = 0.62536
Eye = 39.654,-4.07285,-27.3587
Target = -7.62767,0.783434,5.26259
Up = 0.149814,0.974284,-0.168305
#endpreset

#preset KeyFrame.002
FOV = 0.62536
Eye = 10.7017,-1.09917,-7.38347
Target = -36.58,3.75712,25.2378
Up = 0.149814,0.974284,-0.168305
#endpreset

#preset KeyFrame.003
FOV = 0.62536
Eye = 3.89113,-0.399659,-2.68463
Target = -43.3906,4.45663,29.9366
Up = 0.149814,0.974284,-0.168305
#endpreset

#preset KeyFrame.004
FOV = 0.62536
Eye = 2.07882,-0.213517,-1.43425
Target = -45.2029,4.64277,31.187
Up = 0.149814,0.974284,-0.168305
#endpreset

#preset KeyFrame.005
FOV = 0.62536
Eye = 1.26963,-0.130405,-0.875964
Target = -46.0121,4.72588,31.7453
Up = 0.149814,0.974284,-0.168305
#endpreset

//keywords
break continue do for while if else true false discard return struct 
//types
float int void bool mat2 mat3 mat4 vec2 vec3 vec4 ivec2 ivec3 ivec4 bvec2 bvec3 bvec4 
sampler1D sampler2D sampler3D samplerCube sampler1DShadow sampler2DShadow 
//type qualifiers
attribute const uniform varying in out inout 
//Angle and Trigonometry Functions
radians degrees sin cos tan asin acos atan 
//Exponential Functions
pow exp log exp2 log2 sqrt inversesqrt 
//Common Functions
abs sign floor ceil fract mod min max clamp mix step smoothstep 
//Geometric Functions
length distance dot cross normalize ftransform faceforward reflect refract 
//Matrix Functions
matrixCompMult 
//Vector Relational Functions
lessThan lessThanEqual greaterThan greaterThanEqual equal notEqual any all not 
//Texture Lookup Functions
texture1D texture1DProj texture1DLod texture1DProjLod texture2D texture2DProj texture2DLod texture2DProjLod 
texture3D texture3DProj texture3DLod texture3DProjLod textureCube textureCubeLod shadow1D shadow2D 
shadow1DProj shadow2DProj shadow1DLod shadow2DLod shadow1DProjLod shadow2DProjLod 
//Fragment Processing Functions
dFdx dFdy fwidth 
//Noise Functions
noise1 noise2 noise3 noise4 
//Vertex Shader Special Variables
gl_Position gl_PointSize gl_ClipVertex 
//Fragment Shader Special Variables
gl_FragCoord gl_FragFacing gl_FragColor gl_FragData gl_FragDepth 
// Vertex Shader Built-in Attributes
gl_Color gl_SecondaryColor gl_Normal gl_Vertex gl_MultiTexCoord0 gl_MultiTexCoord1 gl_MultiTexCoord2 gl_MultiTexCoord2 
gl_MultiTexCoord3 gl_MultiTexCoord4 gl_MultiTexCoord5 gl_MultiTexCoord6 gl_MultiTexCoord7 gl_FogColor 
//Built-in Constants
gl_MaxLights gl_MaxClipPlanes gl_MaxTextureUnits gl_MaxTextureCoords gl_MaxVertexAttributes gl_MaxVertexUniformComponents gl_MaxVaryingFloats
gl_MaxVertexTextureImageUnits gl_MaxCombinedTextureImageUnits gl_MaxTextureImageUnits gl_MaxFragmentUniformComponents gl_MaxDrawBuffers 
//Built-in Uniform State
gl_ModelViewMatrix gl_ProjectionMatrix gl_ModelViewProjectionMatrix gl_TextureMatrix gl_NormalMatrix gl_ModelViewMatrixInverse
gl_ProjectionMatrixInverse gl_ModelViewProjectionMatrixInverse  gl_TextureMatrixInverse gl_ModelViewMatrixTranspose
gl_ProjectionMatrixTranspose gl_ModelViewProjectionMatrixTranspose gl_TextureMatrixTranspose gl_ModelViewMatrixInverseTranspose
gl_ProjectionMatrixInverseTranspose gl_ModelViewProjectionMatrixInverseTranspose gl_TextureMatrixInverseTranspose
gl_NormScale gl_DepthRangeParameters gl_DepthRange gl_ClipPlane gl_PointParameters gl_Point gl_MaterialParameters 
gl_FrontMaterial gl_BackMaterial gl_LightSourceParameters gl_LightSource gl_LightModelParameters gl_LightModel gl_LightModelProducts
gl_FrontLightModelProduct gl_BackLightModelProduct gl_LightProducts gl_FrontLightProduct gl_BackLightProduct 
gl_TextureEnvColor gl_EyePlaneS gl_EyePlaneT gl_EyePlaneR gl_EyePlaneQ gl_ObjectPlaneS gl_ObjectPlaneT gl_ObjectPlaneR 
gl_ObjectPlaneQ gl_FogParameters gl_Fog 
//Varying Variables
gl_FrontColor gl_BackColor gl_FrontSecondaryColor gl_BackSecondaryColor gl_TexCoord gl_FogFragCoord gl_Color gl_SecondaryColor 

gl_FragDepth = ((1000.0 / (1000.0 - 0.00001)) +
(1000.0 * 0.00001 / (0.00001 - 1000.0)) /
clamp(Ray.Pos/length(Ray.Direction), 0.00001, 1000.0));

void DisplayWidget::qMultMatrix(QMatrix4x4 mat) {
        if (sizeof(qreal) == sizeof(GLfloat))
            glMultMatrixf((GLfloat*)mat.constData());
#ifndef QT_OPENGL_ES
        else if (sizeof(qreal) == sizeof(GLdouble))
            glMultMatrixd((GLdouble*)mat.constData());
#endif
        else
        {
            GLfloat fmat[16];
#ifdef WIN32
            float const *r = mat.constData();
#else
            double const *r = mat.constData();
#endif
            for (int i = 0; i < 16; ++i)
                fmat[i] = r[i];
            glMultMatrixf(fmat);
        }
    }

 void DisplayWidget::qglPerspective(GLdouble fov, GLdouble aspect, GLdouble zNear, GLdouble zFar) {
        fov = 180.0 * ( 2.0 * atan2(1.0,(1.0/fov)) / 3.1415926535);
        QMatrix4x4 matrix;
        matrix.setToIdentity();
        matrix.perspective(fov, aspect, zNear, zFar);
        qMultMatrix(matrix);
}

	    glDepthFunc(GL_ALWAYS);       // always passes test so we write color
	    glEnable( GL_DEPTH_TEST );    // enable depth testing
	    glDepthMask(GL_TRUE);         // enable depth buffer writing
...GL commands to render quad...

      qglPerspective(fov, aspect, 0.00001, 1000.0);

	    glDepthFunc(GL_LESS);       // closer to eye passes test
	    glDepthMask(GL_FALSE);      // no Writing to depth buffer for splines
	    glEnable( GL_DEPTH_TEST );  // only testing
...GL commands to render splines... 

void DisplayWidget::setPerspective() {
    QStringList cs = mainWindow->getCameraSettings().split("\n");
    float fov = cs.filter("FOV").at(0).split("=").at(1).toFloat();
    QStringList cv = cs.filter("Eye ").at(0).split("=").at(1).split(",");
    QVector3D e = QVector3D(cv.at(0).toFloat(),cv.at(1).toFloat(),cv.at(2).toFloat());
    cv = cs.filter("Target").at(0).split("=").at(1).split(",");
    QVector3D t = QVector3D(cv.at(0).toFloat(),cv.at(1).toFloat(),cv.at(2).toFloat());
    cv = cs.filter("Up").at(0).split("=").at(1).split(",");
    QVector3D u = QVector3D(cv.at(0).toFloat(),cv.at(1).toFloat(),cv.at(2).toFloat());
    fov = 180.0 * ( 2.0 * atan2(1.0,(1.0/fov)) / 3.1415926535);

    QMatrix4x4 matrix;
    matrix.setToIdentity();
    matrix.perspective(fov, ((float)width()/(float)height()), 0.00001, 1000.0);
    matrix.lookAt(e,t,u);

    glLoadMatrixf(matrix.constData());
}

deviceQueryDrv Starting...

CUDA Device Query (Driver API) statically linked version 
Detected 1 CUDA Capable device(s)

Device 0: "GeForce GTX 760"
  CUDA Driver Version:                           8.0
  CUDA Capability Major/Minor version number:    3.0
  Total amount of global memory:                 1994 MBytes (2090991616 bytes)
  ( 6) Multiprocessors x (192) CUDA Cores/MP:    1152 CUDA Cores
  GPU Clock rate:                                1058 MHz (1.06 GHz)
  Memory Clock rate:                             3004 Mhz
  Memory Bus Width:                              256-bit
  L2 Cache Size:                                 524288 bytes
  Max Texture Dimension Sizes                    1D=(65536) 2D=(65536,65536) 3D=(4096,4096,4096)
  Max Layered Texture Size (dim) x layers        1D=(16384) x 2048, 2D=(16384,16384) x 2048
  Total amount of constant memory:               65536 bytes
  Total amount of shared memory per block:       49152 bytes
  Total number of registers available per block: 65536
  Warp size:                                     32
  Maximum number of threads per multiprocessor:  2048
  Maximum number of threads per block:           1024
  Maximum sizes of each dimension of a block:    1024 x 1024 x 64
  Maximum sizes of each dimension of a grid:     2147483647 x 65535 x 65535
  Texture alignment:                             512 bytes
  Maximum memory pitch:                          2147483647 bytes
  Concurrent copy and kernel execution:          Yes with 1 copy engine(s)
  Run time limit on kernels:                     Yes
  Integrated GPU sharing Host Memory:            No
  Support host page-locked memory mapping:       Yes
  Concurrent kernel execution:                   Yes
  Alignment requirement for Surfaces:            Yes
  Device has ECC support:                        Disabled
  Device supports Unified Addressing (UVA):      Yes
  Device PCI Bus ID / PCI location ID:           1 / 0
  Compute Mode:
     < Default (multiple host threads can use ::cudaSetDevice() with device simultaneously) >

# ON to compile with AsmBrowser enabled requires nVidia + GL > 4.0
OPTION ( NVIDIAGL4PLUS "Build for nVidia GL v4+" OFF)
# ON if you have OpenEXR libs and include files
OPTION ( USE_OPEN_EXR "Build with OpenEXR" OFF)