├── .gitignore ├── Makefile ├── Project.xcconfig ├── README.md ├── addons.make ├── bin ├── data │ └── shaders │ │ ├── 3Dlabs-license.txt │ │ ├── CarToPol_GLSL.frag │ │ ├── CarToPol_GLSL.vert │ │ ├── ChromaAb_GLSL.frag │ │ ├── ChromaAb_GLSL.vert │ │ ├── Fisheye_GLSL.frag │ │ ├── Fisheye_GLSL.vert │ │ ├── Gauss_GLSL.frag │ │ ├── Gauss_GLSL.vert │ │ ├── LumaKey_GLSL.frag │ │ ├── LumaKey_GLSL.vert │ │ ├── Rota_GLSL.frag │ │ ├── Rota_GLSL.vert │ │ ├── Wobble_GLSL.frag │ │ ├── Wobble_GLSL.vert │ │ ├── bloom_GLSL.frag │ │ ├── bloom_GLSL.vert │ │ ├── brcosa_GLSL.frag │ │ ├── brcosa_GLSL.vert │ │ └── vertexChomAbPassthrough.glsl └── emptyExampleDebug.app │ └── Contents │ ├── Frameworks │ └── GLUT.framework │ │ ├── GLUT │ │ ├── Headers │ │ ├── Resources │ │ └── Versions │ │ ├── A │ │ ├── GLUT │ │ ├── Headers │ │ │ ├── copy.h │ │ │ ├── extrude.h │ │ │ ├── glsmap.h │ │ │ ├── glsmapint.h │ │ │ ├── glut.h │ │ │ ├── glutbitmap.h │ │ │ ├── glutf90.h │ │ │ ├── glutstroke.h │ │ │ ├── gutil.h │ │ │ ├── intersect.h │ │ │ ├── port.h │ │ │ ├── rot.h │ │ │ ├── segment.h │ │ │ ├── tube.h │ │ │ ├── tube_gc.h │ │ │ └── vvector.h │ │ └── Resources │ │ │ ├── Caution.tiff │ │ │ ├── English.lproj │ │ │ ├── GLUT.nib │ │ │ │ ├── classes.nib │ │ │ │ ├── info.nib │ │ │ │ └── objects.nib │ │ │ ├── GLUTClipboard.nib │ │ │ │ ├── classes.nib │ │ │ │ ├── info.nib │ │ │ │ └── objects.nib │ │ │ ├── GLUTPreferences.nib │ │ │ │ ├── classes.nib │ │ │ │ ├── info.nib │ │ │ │ └── objects.nib │ │ │ ├── GLUTUI.strings │ │ │ └── InfoPlist.strings │ │ │ ├── Info.plist │ │ │ ├── blankCursor.tiff │ │ │ ├── bottomCursor.tiff │ │ │ ├── bottomleftCursor.tiff │ │ │ ├── bottomrightCursor.tiff │ │ │ ├── crossCursor.tiff │ │ │ ├── cycleCursor.tiff │ │ │ ├── destroyCursor.tiff │ │ │ ├── fingerCursor.tiff │ │ │ ├── helpCursor.tiff │ │ │ ├── leftCursor.tiff │ │ │ ├── leftRightCursor.tiff │ │ │ ├── rightArrowCursor.tiff │ │ │ ├── rightCursor.tiff │ │ │ ├── sprayCursor.tiff │ │ │ ├── topCursor.tiff │ │ │ ├── topleftCursor.tiff │ │ │ ├── toprightCursor.tiff │ │ │ ├── upDownCursor.tiff │ │ │ └── waitCursor.tiff │ │ └── Current │ ├── Info.plist │ ├── MacOS │ ├── emptyExampleDebug │ └── libfmodex.dylib │ └── PkgInfo ├── config.make ├── openFrameworks-Info.plist ├── screengrab.png ├── shaderSandbox.xcodeproj ├── project.pbxproj ├── project.xcworkspace │ ├── contents.xcworkspacedata │ └── xcuserdata │ │ └── laser.xcuserdatad │ │ └── UserInterfaceState.xcuserstate ├── xcshareddata │ └── xcschemes │ │ ├── shaderSandbox Debug.xcscheme │ │ └── shaderSandbox Release.xcscheme └── xcuserdata │ └── laser.xcuserdatad │ └── xcschemes │ └── xcschememanagement.plist └── src ├── main.cpp ├── ofApp.cpp └── ofApp.h /.gitignore: -------------------------------------------------------------------------------- 1 | *.depend 2 | *.layout 3 | *.mode*v3 4 | *.pbxuser 5 | *.app* 6 | *.DS_* 7 | 8 | .svn/ 9 | obj/ 10 | bin/ 11 | build/ 12 | !data/ -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | # Attempt to load a config.make file. 2 | # If none is found, project defaults in config.project.make will be used. 3 | ifneq ($(wildcard config.make),) 4 | include config.make 5 | endif 6 | 7 | # make sure the the OF_ROOT location is defined 8 | ifndef OF_ROOT 9 | OF_ROOT=$(realpath ../../..) 10 | endif 11 | 12 | # call the project makefile! 13 | include $(OF_ROOT)/libs/openFrameworksCompiled/project/makefileCommon/compile.project.mk 14 | -------------------------------------------------------------------------------- /Project.xcconfig: -------------------------------------------------------------------------------- 1 | //THE PATH TO THE ROOT OF OUR OF PATH RELATIVE TO THIS PROJECT. 2 | //THIS NEEDS TO BE DEFINED BEFORE CoreOF.xcconfig IS INCLUDED 3 | OF_PATH = ../../.. 4 | 5 | //THIS HAS ALL THE HEADER AND LIBS FOR OF CORE 6 | #include "../../../libs/openFrameworksCompiled/project/osx/CoreOF.xcconfig" 7 | 8 | //ICONS - NEW IN 0072 9 | ICON_NAME_DEBUG = icon-debug.icns 10 | ICON_NAME_RELEASE = icon.icns 11 | ICON_FILE_PATH = $(OF_PATH)/libs/openFrameworksCompiled/project/osx/ 12 | 13 | //IF YOU WANT AN APP TO HAVE A CUSTOM ICON - PUT THEM IN YOUR DATA FOLDER AND CHANGE ICON_FILE_PATH to: 14 | //ICON_FILE_PATH = bin/data/ 15 | 16 | OTHER_LDFLAGS = $(OF_CORE_LIBS) $(OF_CORE_FRAMEWORKS) 17 | HEADER_SEARCH_PATHS = $(OF_CORE_HEADERS) 18 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | All shaders are the property of their original creators! 2 | 3 | This is meant purely as an exercise/tutorial in using shaders for image processing in openFrameworks. I had a great learning experience putting this together, so I figured I'd share in case someone else was interested in playing with them. 4 | 5 | I got most of my image processing experience with Jitter, so most shaders were lifted or modified from the Cycling '74 Jitter core, but I stayed away from any of the Cycling '74 copyright shaders. Most of these are either ones you could modify from the Orange book, or are from the OF forum. 6 | 7 | Examples Include: 8 | 9 | - Gauss Blur (eh..sorta) 10 | - Wobble 11 | - Rota (resize/rotate/manipulate a texture via a shader) 12 | - RGB channel shift 13 | - Bloom (currently broken) 14 | - BRCOSA (brightness, contrast, saturation) 15 | - Luma Key (broken) 16 | - Bloom+BRCOSA (via FBO) (broken) 17 | - Wobble+ChromaAbberation (via FBO) 18 | - Fisheye 19 | - Cartesian to Polar 20 | 21 | ![Screengrab](https://raw.github.com/laserpilot/shaderSandbox/master/screengrab.png) 22 | 23 | -------------------------------------------------------------------------------- /addons.make: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/laserpilot/shaderSandbox/32c692f28779ba0c5f30aefb3958ec38e3f21f4e/addons.make -------------------------------------------------------------------------------- /bin/data/shaders/3Dlabs-license.txt: -------------------------------------------------------------------------------- 1 | /************************************************************************ 2 | * * 3 | * Copyright (C) 2002-2005 3Dlabs Inc. Ltd. * 4 | * * 5 | * All rights reserved. * 6 | * * 7 | * Redistribution and use in source and binary forms, with or without * 8 | * modification, are permitted provided that the following conditions * 9 | * are met: * 10 | * * 11 | * Redistributions of source code must retain the above copyright * 12 | * notice, this list of conditions and the following disclaimer. * 13 | * * 14 | * Redistributions in binary form must reproduce the above * 15 | * copyright notice, this list of conditions and the following * 16 | * disclaimer in the documentation and/or other materials provided * 17 | * with the distribution. * 18 | * * 19 | * Neither the name of 3Dlabs Inc. Ltd. nor the names of its * 20 | * contributors may be used to endorse or promote products derived * 21 | * from this software without specific prior written permission. * 22 | * * 23 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * 24 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * 25 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS * 26 | * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE * 27 | * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, * 28 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, * 29 | * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * 30 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER * 31 | * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * 32 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN * 33 | * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * 34 | * POSSIBILITY OF SUCH DAMAGE. * 35 | * * 36 | ************************************************************************/ -------------------------------------------------------------------------------- /bin/data/shaders/CarToPol_GLSL.frag: -------------------------------------------------------------------------------- 1 | //setup for 2 texture 2 | varying vec2 texcoord0; 3 | varying vec2 texdim0; 4 | uniform vec2 origin; 5 | uniform vec2 scale; 6 | uniform sampler2DRect tex0; 7 | const float pi=3.1415926; 8 | 9 | 10 | void main() 11 | { 12 | vec2 point = abs(mod((texcoord0/texdim0)*scale+origin,1.));//normalize coordinates 13 | 14 | // cartesian to polar conversion 15 | vec2 dt = 2.*(point-0.5); 16 | float radius = sqrt(dot(dt,dt)); //hypot 17 | float theta = atan(dt.y,dt.x)+pi; 18 | vec2 topol = vec2(radius,theta/(2.*pi))*texdim0; 19 | vec4 a = texture2DRect(tex0,topol); 20 | // output texture 21 | gl_FragColor = a; 22 | } -------------------------------------------------------------------------------- /bin/data/shaders/CarToPol_GLSL.vert: -------------------------------------------------------------------------------- 1 | varying vec2 texcoord0; 2 | varying vec2 texcoord1; 3 | varying vec2 texdim0; 4 | varying vec2 texdim1; 5 | varying vec2 texorient0; 6 | varying vec2 texorient1; 7 | 8 | void main() 9 | { 10 | // perform standard transform on vertex 11 | gl_Position = ftransform(); 12 | 13 | // transform texcoords 14 | texcoord0 = vec2(gl_TextureMatrix[0] * gl_MultiTexCoord0); 15 | texcoord1 = vec2(gl_TextureMatrix[1] * gl_MultiTexCoord1); 16 | // extract the x and y scalars from the texture matrix to determine dimensions 17 | texdim0 = vec2 (abs(gl_TextureMatrix[0][0][0]),abs(gl_TextureMatrix[0][1][1])); 18 | texdim1 = vec2 (abs(gl_TextureMatrix[1][0][0]),abs(gl_TextureMatrix[1][1][1])); 19 | // extract the sign for orientation 20 | texorient0 = vec2 (gl_TextureMatrix[0][0][0]/texdim0.x,gl_TextureMatrix[0][1][1]/texdim0.y); 21 | texorient1 = vec2 (gl_TextureMatrix[1][0][0]/texdim1.x,gl_TextureMatrix[1][1][1]/texdim1.y); 22 | } -------------------------------------------------------------------------------- /bin/data/shaders/ChromaAb_GLSL.frag: -------------------------------------------------------------------------------- 1 | uniform sampler2DRect tex; 2 | uniform vec2 windowSize; 3 | uniform float offsetALL; 4 | 5 | varying vec2 texcoord0; 6 | 7 | 8 | void main() 9 | { 10 | //vec2 offset = ( gl_FragCoord.xy/windowSize - vec2( 0.5 ) ) * 0.005; 11 | vec2 offset = ( gl_FragCoord.xy/windowSize - vec2( 0.5 ) ) * offsetALL; 12 | 13 | float rChannel = texture2DRect( tex, texcoord0 ).r; 14 | float gChannel = texture2DRect( tex, texcoord0 + offset ).g; 15 | float bChannel = texture2DRect( tex, texcoord0 + offset * 2.0 ).b; 16 | vec3 finalCol = vec3( rChannel, gChannel, bChannel ); 17 | 18 | gl_FragColor.rgb = finalCol; 19 | gl_FragColor.a = 1.0; 20 | } -------------------------------------------------------------------------------- /bin/data/shaders/ChromaAb_GLSL.vert: -------------------------------------------------------------------------------- 1 | varying vec2 texcoord0; 2 | varying vec2 texcoord1; 3 | varying vec2 texdim0; 4 | varying vec2 texdim1; 5 | varying vec2 texorient0; 6 | varying vec2 texorient1; 7 | 8 | void main() 9 | { 10 | // perform standard transform on vertex 11 | gl_Position = ftransform(); 12 | 13 | // transform texcoords 14 | texcoord0 = vec2(gl_TextureMatrix[0] * gl_MultiTexCoord0); 15 | texcoord1 = vec2(gl_TextureMatrix[1] * gl_MultiTexCoord1); 16 | // extract the x and y scalars from the texture matrix to determine dimensions 17 | texdim0 = vec2 (abs(gl_TextureMatrix[0][0][0]),abs(gl_TextureMatrix[0][1][1])); 18 | texdim1 = vec2 (abs(gl_TextureMatrix[1][0][0]),abs(gl_TextureMatrix[1][1][1])); 19 | // extract the sign for orientation 20 | texorient0 = vec2 (gl_TextureMatrix[0][0][0]/texdim0.x,gl_TextureMatrix[0][1][1]/texdim0.y); 21 | texorient1 = vec2 (gl_TextureMatrix[1][0][0]/texdim1.x,gl_TextureMatrix[1][1][1]/texdim1.y); 22 | } -------------------------------------------------------------------------------- /bin/data/shaders/Fisheye_GLSL.frag: -------------------------------------------------------------------------------- 1 | /////////////////////////////////////////////////////////////////////////////// 2 | // 3 | // Copyright 2003, ATI Technologies, Inc., All rights reserved. 4 | // 5 | // Permission to use, copy, modify, and distribute this software and its 6 | // documentation for any purpose and without fee is hereby granted, 7 | // provided that the above copyright notice appear in all copies and derivative 8 | // works and that both the copyright notice and this permission notice appear in 9 | // support documentation, and that the name of ATI Technologies, Inc. not be used 10 | // in advertising or publicity pertaining to distribution of the software without 11 | // specific, written prior permission. 12 | // 13 | /////////////////////////////////////////////////////////////////////////////// 14 | 15 | #define EPSILON 0.000011 16 | 17 | // vertex to fragment shader io 18 | varying vec2 texcoord0; 19 | varying vec2 texdim0; 20 | 21 | // globals 22 | uniform float lensradius; 23 | uniform float signcurvature; 24 | 25 | // samplers 26 | uniform sampler2DRect tex0; 27 | 28 | // entry point 29 | void 30 | main() 31 | { 32 | float curvature = abs(signcurvature); 33 | float extent = lensradius; 34 | float optics = extent / log2(curvature * extent + 1.0) / 1.4427; 35 | vec2 normalizeTD = texcoord0/texdim0; 36 | vec2 PP = normalizeTD - vec2(0.5,0.5); 37 | float P0 = PP[0]; 38 | float P1 = PP[1]; 39 | float radius = sqrt(P0 * P0 + P1 * P1); 40 | 41 | float cosangle = P0 / radius; 42 | float sinangle = P1 / radius; 43 | 44 | float rad1, rad2, newradius; 45 | rad1 = (exp2((radius / optics) * 1.4427) - 1.0) / curvature; 46 | rad2 = optics * log2(1.0 + curvature * radius) / 1.4427; 47 | newradius = signcurvature > 0.0 ? rad1 : rad2; 48 | 49 | vec2 FE = vec2(newradius * cosangle + 0.5,newradius * sinangle + 0.5); 50 | FE = radius <= extent ? FE : normalizeTD; 51 | FE = curvature < EPSILON ? normalizeTD : FE; 52 | 53 | gl_FragColor = texture2DRect(tex0, FE*texdim0); 54 | } 55 | -------------------------------------------------------------------------------- /bin/data/shaders/Fisheye_GLSL.vert: -------------------------------------------------------------------------------- 1 | varying vec2 texcoord0; 2 | varying vec2 texcoord1; 3 | varying vec2 texdim0; 4 | varying vec2 texdim1; 5 | varying vec2 texorient0; 6 | varying vec2 texorient1; 7 | 8 | void main() 9 | { 10 | // perform standard transform on vertex 11 | gl_Position = ftransform(); 12 | 13 | // transform texcoords 14 | texcoord0 = vec2(gl_TextureMatrix[0] * gl_MultiTexCoord0); 15 | texcoord1 = vec2(gl_TextureMatrix[1] * gl_MultiTexCoord1); 16 | // extract the x and y scalars from the texture matrix to determine dimensions 17 | texdim0 = vec2 (abs(gl_TextureMatrix[0][0][0]),abs(gl_TextureMatrix[0][1][1])); 18 | texdim1 = vec2 (abs(gl_TextureMatrix[1][0][0]),abs(gl_TextureMatrix[1][1][1])); 19 | // extract the sign for orientation 20 | texorient0 = vec2 (gl_TextureMatrix[0][0][0]/texdim0.x,gl_TextureMatrix[0][1][1]/texdim0.y); 21 | texorient1 = vec2 (gl_TextureMatrix[1][0][0]/texdim1.x,gl_TextureMatrix[1][1][1]/texdim1.y); 22 | } -------------------------------------------------------------------------------- /bin/data/shaders/Gauss_GLSL.frag: -------------------------------------------------------------------------------- 1 | //Gauss blur 2 | uniform sampler2DRect image; 3 | 4 | varying vec2 texcoordM; 5 | varying vec2 texcoordB0; 6 | varying vec2 texcoordF0; 7 | varying vec2 texcoordB1; 8 | varying vec2 texcoordF1; 9 | varying vec2 texcoordB2; 10 | varying vec2 texcoordF2; 11 | 12 | void main(){ 13 | vec4 sampleM = texture2DRect(image, texcoordM); 14 | vec4 sampleB0 = texture2DRect(image, texcoordB0); 15 | vec4 sampleF0 = texture2DRect(image, texcoordF0); 16 | vec4 sampleB1 = texture2DRect(image, texcoordB1); 17 | vec4 sampleF1 = texture2DRect(image, texcoordF1); 18 | vec4 sampleB2 = texture2DRect(image, texcoordB2); 19 | vec4 sampleF2 = texture2DRect(image, texcoordF2); 20 | 21 | gl_FragColor = 0.1752 * sampleM + 0.1658 * (sampleB0 + sampleF0) + 0.1403 * (sampleB1 + sampleF1) + 0.1063 * (sampleB2 + sampleF2); 22 | } -------------------------------------------------------------------------------- /bin/data/shaders/Gauss_GLSL.vert: -------------------------------------------------------------------------------- 1 | uniform vec2 width; 2 | 3 | varying vec2 texcoordM; 4 | varying vec2 texcoordB0; 5 | varying vec2 texcoordF0; 6 | varying vec2 texcoordB1; 7 | varying vec2 texcoordF1; 8 | varying vec2 texcoordB2; 9 | varying vec2 texcoordF2; 10 | 11 | 12 | void main() 13 | { 14 | // perform standard transform on vertex 15 | gl_Position = ftransform(); 16 | 17 | // transform texcoord 18 | vec2 texcoord = vec2(gl_TextureMatrix[0] * gl_MultiTexCoord0); 19 | 20 | // get sample positions 21 | texcoordM = texcoord; 22 | texcoordB0 = texcoord - width; 23 | texcoordF0 = texcoord + width; 24 | texcoordB1 = texcoord - width * 2.0; 25 | texcoordF1 = texcoord + width * 2.0; 26 | texcoordB2 = texcoord - width * 3.0; 27 | texcoordF2 = texcoord + width * 3.0; 28 | } -------------------------------------------------------------------------------- /bin/data/shaders/LumaKey_GLSL.frag: -------------------------------------------------------------------------------- 1 | // texcoords 2 | varying vec2 texcoord0; 3 | varying vec2 texcoord1; 4 | 5 | // samplers 6 | uniform sampler2DRect tex0; 7 | uniform sampler2DRect tex1; 8 | 9 | // blend amount 10 | uniform float luma; 11 | uniform float tol; 12 | uniform float fade; 13 | uniform float invert; 14 | uniform float mode; 15 | uniform float binary; 16 | uniform vec4 lumcoeff; 17 | 18 | // entry point 19 | void main() 20 | { 21 | vec4 one = vec4(1.0); 22 | 23 | vec4 a = texture2DRect(tex0, texcoord0); 24 | vec4 b = texture2DRect(tex1, texcoord1); 25 | 26 | // calculate our luminance 27 | float luminance = dot(a,lumcoeff); 28 | 29 | // measure distance from target 30 | float delta = abs(luminance-luma); 31 | 32 | // determine scaling coefficient witin our fade range 33 | float scale = smoothstep(abs(tol),abs(tol)+abs(fade),delta); 34 | 35 | // invert if necessary 36 | float mixamount = mix(scale,1.-scale,invert); 37 | 38 | // blend between sources based on mixamount 39 | vec4 result = mix(b,a,vec4(mixamount)); 40 | 41 | // if not binary just set alpha value 42 | a.a = mixamount; 43 | result = mix(a,result,vec4(binary)); 44 | 45 | // result either blend or mask based on mode 46 | gl_FragColor = mix(result,vec4(mixamount),vec4(mode)); 47 | 48 | // setting the fragment color is a useful means of debugging 49 | //gl_FragColor = vec4(luminance); 50 | } 51 | -------------------------------------------------------------------------------- /bin/data/shaders/LumaKey_GLSL.vert: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * Derek Gerstmann - derek@cycling74.com 4 | * Copyright 2005 - Cycling '74 5 | * 6 | * GLSL vertex program for doing a standard vertex transform and 7 | * with texture coordinates. 8 | * 9 | */ 10 | 11 | varying vec2 texcoord0; 12 | varying vec2 texcoord1; 13 | varying vec2 texcoord2; 14 | varying vec2 texcoord3; 15 | varying vec2 texcoord4; 16 | varying vec2 texcoord5; 17 | varying vec2 texcoord6; 18 | varying vec2 texcoord7; 19 | 20 | void main() 21 | { 22 | // perform standard transform on vertex 23 | gl_Position = ftransform(); 24 | 25 | // transform texcoords 26 | texcoord0 = vec2(gl_TextureMatrix[0] * gl_MultiTexCoord0); 27 | texcoord1 = vec2(gl_TextureMatrix[1] * gl_MultiTexCoord1); 28 | texcoord2 = vec2(gl_TextureMatrix[2] * gl_MultiTexCoord2); 29 | texcoord3 = vec2(gl_TextureMatrix[3] * gl_MultiTexCoord3); 30 | texcoord4 = vec2(gl_TextureMatrix[4] * gl_MultiTexCoord4); 31 | texcoord5 = vec2(gl_TextureMatrix[5] * gl_MultiTexCoord5); 32 | texcoord6 = vec2(gl_TextureMatrix[6] * gl_MultiTexCoord6); 33 | texcoord7 = vec2(gl_TextureMatrix[7] * gl_MultiTexCoord7); 34 | } -------------------------------------------------------------------------------- /bin/data/shaders/Rota_GLSL.frag: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 4 | 5 | 6 | 7 | */ 8 | 9 | //setup for 2 texture 10 | varying vec2 texcoord0; 11 | varying vec2 texcoord1; 12 | varying vec2 texdim0; 13 | uniform vec2 zoom; 14 | uniform vec2 offset; 15 | uniform float theta; 16 | uniform vec2 anchor; 17 | uniform int boundmode; 18 | uniform sampler2DRect tex0; 19 | uniform sampler2DRect tex1; 20 | const float pi=3.1415926; 21 | 22 | void main() 23 | { 24 | // where is the point? 25 | vec2 sizea = texdim0; 26 | vec2 point = texcoord0; 27 | 28 | //transormation matrices 29 | mat2 sca = mat2 (1./zoom.x,0.,0.,1./zoom.y);//scaling matrix (zoom) 30 | mat2 rot = mat2 (cos(theta),sin(theta),-sin(theta),cos(theta));//rotation matrix 31 | 32 | //perform transform 33 | vec2 no = ((((point-anchor*sizea)*rot)*sca)+anchor*sizea)+offset; 34 | 35 | //create boundmodes 36 | vec2 no2 = mod(no,sizea);//wrap 37 | 38 | vec2 no4 = mix(mod(no,sizea),sizea-mod(no,sizea),floor(mod(no,sizea*2.)/sizea));//folded coords 39 | 40 | // sampler coord 41 | vec2 tc = no*float(boundmode==0) + no*float(boundmode==1) + no2*float(boundmode==2) + no*float(boundmode==3) + no4*float(boundmode==4); 42 | 43 | 44 | //sample textures 45 | vec4 smp0 = texture2DRect(tex0,tc); 46 | vec4 smp1 = texture2DRect(tex1,texcoord0); 47 | 48 | vec2 outbound = sign(floor(no/sizea));//check for point>size 49 | float boundchk = float(sign(float(outbound.x!=0.)+float(outbound.y!=0.))); 50 | float checkm0 = float(boundmode==0)*boundchk; 51 | float checkm1 = float(boundmode==1)*float(boundchk==0.); 52 | vec4 ifb0 = mix(smp0,smp1,checkm0);//ignore 53 | vec4 final = ifb0*float(boundmode != 1) + ifb0*float(checkm1==1.);//clear 54 | 55 | 56 | // output texture 57 | gl_FragColor = final; 58 | } 59 | -------------------------------------------------------------------------------- /bin/data/shaders/Rota_GLSL.vert: -------------------------------------------------------------------------------- 1 | varying vec2 texcoord0; 2 | varying vec2 texcoord1; 3 | varying vec2 texdim0; 4 | varying vec2 texdim1; 5 | varying vec2 texorient0; 6 | varying vec2 texorient1; 7 | 8 | void main() 9 | { 10 | // perform standard transform on vertex 11 | gl_Position = ftransform(); 12 | 13 | // transform texcoords 14 | texcoord0 = vec2(gl_TextureMatrix[0] * gl_MultiTexCoord0); 15 | texcoord1 = vec2(gl_TextureMatrix[1] * gl_MultiTexCoord1); 16 | // extract the x and y scalars from the texture matrix to determine dimensions 17 | texdim0 = vec2 (abs(gl_TextureMatrix[0][0][0]),abs(gl_TextureMatrix[0][1][1])); 18 | texdim1 = vec2 (abs(gl_TextureMatrix[1][0][0]),abs(gl_TextureMatrix[1][1][1])); 19 | // extract the sign for orientation 20 | texorient0 = vec2 (gl_TextureMatrix[0][0][0]/texdim0.x,gl_TextureMatrix[0][1][1]/texdim0.y); 21 | texorient1 = vec2 (gl_TextureMatrix[1][0][0]/texdim1.x,gl_TextureMatrix[1][1][1]/texdim1.y); 22 | } -------------------------------------------------------------------------------- /bin/data/shaders/Wobble_GLSL.frag: -------------------------------------------------------------------------------- 1 | // Constants 2 | const float C_PI = 3.1415; 3 | const float C_2PI = 2.0 * C_PI; 4 | const float C_2PI_I = 1.0 / (2.0 * C_PI); 5 | const float C_PI_2 = C_PI / 2.0; 6 | 7 | varying float lightintensity; 8 | 9 | uniform float radius; 10 | uniform vec2 freq; 11 | uniform vec2 amp; 12 | 13 | uniform sampler2DRect image; 14 | 15 | void main (void) 16 | { 17 | vec2 perturb; 18 | float rad; 19 | vec3 color; 20 | 21 | // Compute a perturbation factor for the x-direction 22 | rad = (gl_TexCoord[0].s + gl_TexCoord[0].t - 1.0 + radius) * freq.x; 23 | 24 | // Wrap to -2.0*PI, 2*PI 25 | rad = rad * C_2PI_I; 26 | rad = fract(rad); 27 | rad = rad * C_2PI; 28 | 29 | // Center in -PI, PI 30 | if (rad > C_PI) rad = rad - C_2PI; 31 | if (rad < -C_PI) rad = rad + C_2PI; 32 | 33 | // Center in -PI/2, PI/2 34 | if (rad > C_PI_2) rad = C_PI - rad; 35 | if (rad < -C_PI_2) rad = -C_PI - rad; 36 | 37 | perturb.x = (rad - (rad * rad * rad / 6.0)) * amp.x; 38 | 39 | // Now compute a perturbation factor for the y-direction 40 | rad = (gl_TexCoord[0].s - gl_TexCoord[0].t + radius) * freq.y; 41 | 42 | // Wrap to -2*PI, 2*PI 43 | rad = rad * C_2PI_I; 44 | rad = fract(rad); 45 | rad = rad * C_2PI; 46 | 47 | // Center in -PI, PI 48 | if (rad > C_PI) rad = rad - C_2PI; 49 | if (rad < -C_PI) rad = rad + C_2PI; 50 | 51 | // Center in -PI/2, PI/2 52 | if (rad > C_PI_2) rad = C_PI - rad; 53 | if (rad < -C_PI_2) rad = -C_PI - rad; 54 | 55 | perturb.y = (rad - (rad * rad * rad / 6.0)) * amp.y; 56 | 57 | color = vec3 (texture2DRect(image, perturb + gl_TexCoord[0].st)); 58 | 59 | gl_FragColor = vec4 (color, 1.0); 60 | } 61 | -------------------------------------------------------------------------------- /bin/data/shaders/Wobble_GLSL.vert: -------------------------------------------------------------------------------- 1 | //varying float lightintensity; 2 | uniform vec3 lightpos; 3 | 4 | const float ks = 0.1; 5 | const float kd = 1.0 - ks; 6 | 7 | void main(void) 8 | { 9 | 10 | //vec3 lightpos = (0.0,0.0,0.0); //Unused Used to be applicable, but leaving it in case someone finds it useful. 11 | vec3 pos = vec3 (gl_ModelViewMatrix * gl_Vertex); 12 | vec3 tnorm = normalize(gl_NormalMatrix * gl_Normal); 13 | vec3 lightVec = normalize(lightpos - pos); 14 | vec3 reflectVec = reflect(-lightVec, tnorm); 15 | vec3 viewVec = normalize(-pos); 16 | 17 | float spec = max(dot(reflectVec, viewVec), 0.0); 18 | spec = pow(spec, 16.0); 19 | 20 | //lightintensity = kd * max(dot(lightVec, tnorm), 0.0)+ ks * spec; 21 | 22 | gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0; 23 | gl_Position = ftransform(); 24 | } 25 | -------------------------------------------------------------------------------- /bin/data/shaders/bloom_GLSL.frag: -------------------------------------------------------------------------------- 1 | #version 120 2 | //#extension GL_EXT_gpu_shader4: enable 3 | //#extension GL_ARB_texture_rectangle : enable 4 | 5 | // define our varying texture coordinates 6 | varying vec2 texCoord; 7 | uniform sampler2DRect tex0; 8 | uniform float bloom; 9 | 10 | 11 | void main() 12 | { 13 | vec4 sum, dry; 14 | int i, j; 15 | 16 | for( i = -3 ;i <= 3; i++) 17 | { 18 | for (j = -3; j <= 3; j++) 19 | { 20 | sum += texture2DRect(tex0, texCoord + vec2(j, i) * 2.0) * 0.25; // 2.0 = "radius step" 21 | } 22 | } 23 | 24 | sum = sum * sum * 0.012; // 0.012 = arbitrary value 25 | dry = texture2DRect(tex0, texCoord); 26 | gl_FragColor = bloom * (1.0 - ((1.0 - sum) * (1.0 - dry))) + ((1.0 - bloom) * dry); // screen mode blending 27 | 28 | } -------------------------------------------------------------------------------- /bin/data/shaders/bloom_GLSL.vert: -------------------------------------------------------------------------------- 1 | #version 120 2 | 3 | varying vec2 texCoord; 4 | 5 | void main() 6 | { 7 | texCoord = vec2(gl_MultiTexCoord0); 8 | gl_Position = gl_ProjectionMatrix * gl_ModelViewMatrix * gl_Vertex; 9 | } 10 | -------------------------------------------------------------------------------- /bin/data/shaders/brcosa_GLSL.frag: -------------------------------------------------------------------------------- 1 | // 2 | // Fragment shader for modifying image contrast by 3 | // interpolation and extrapolation 4 | // 5 | // Author: Randi Rost 6 | // 7 | // Copyright (c) 2002: 3Dlabs, Inc. 8 | // 9 | // See 3Dlabs-License.txt for license information 10 | // 11 | 12 | const vec3 LumCoeff = vec3 (0.2125, 0.7154, 0.0721); 13 | 14 | varying vec2 texcoord; 15 | uniform sampler2DRect image; 16 | 17 | uniform vec3 avgluma; 18 | uniform float saturation; 19 | uniform float contrast; 20 | uniform float brightness; 21 | uniform float alpha; 22 | 23 | void main (void) 24 | { 25 | vec3 texColor = texture2DRect(image, texcoord).rgb; 26 | vec3 intensity = vec3 (dot(texColor, LumCoeff)); 27 | vec3 color = mix(intensity, texColor, saturation); 28 | color = mix(avgluma, color, contrast); 29 | color *= brightness; 30 | gl_FragColor = vec4 (color, color.g*alpha); 31 | } 32 | -------------------------------------------------------------------------------- /bin/data/shaders/brcosa_GLSL.vert: -------------------------------------------------------------------------------- 1 | // 2 | // Vertex shader for modifying image contrast by 3 | // interpolation and extrapolation 4 | // 5 | // Author: Randi Rost 6 | // 7 | // Copyright (c) 2003-2005: 3Dlabs, Inc. 8 | // 9 | // See 3Dlabs-License.txt for license information 10 | // 11 | 12 | varying vec2 texcoord; 13 | 14 | void main (void) 15 | 16 | { 17 | gl_Position = ftransform(); 18 | texcoord = vec2(gl_TextureMatrix[0] * gl_MultiTexCoord0); 19 | } -------------------------------------------------------------------------------- /bin/data/shaders/vertexChomAbPassthrough.glsl: -------------------------------------------------------------------------------- 1 | #version 120 2 | 3 | varying vec3 vVertex; 4 | varying vec4 vColor; 5 | void main() 6 | { 7 | vVertex = gl_Vertex.xyz; 8 | vColor = gl_Color; 9 | gl_TexCoord[0] = gl_MultiTexCoord0; 10 | gl_Position = ftransform(); 11 | } 12 | -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/GLUT: -------------------------------------------------------------------------------- 1 | Versions/Current/GLUT -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Headers: -------------------------------------------------------------------------------- 1 | Versions/Current/Headers -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Resources: -------------------------------------------------------------------------------- 1 | Versions/Current/Resources -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/GLUT: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/laserpilot/shaderSandbox/32c692f28779ba0c5f30aefb3958ec38e3f21f4e/bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/GLUT -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Headers/copy.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * 4 | * Written By Linas Vepstas November 1991 5 | */ 6 | 7 | 8 | #define COPY_THREE_WORDS(A,B) { \ 9 | struct three_words { int a, b, c, }; \ 10 | *(struct three_words *) (A) = *(struct three_words *) (B); \ 11 | } 12 | 13 | #define COPY_FOUR_WORDS(A,B) { \ 14 | struct four_words { int a, b, c, d, }; \ 15 | *(struct four_words *) (A) = *(struct four_words *) (B); \ 16 | } 17 | 18 | /* ============================================================= */ 19 | -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Headers/extrude.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * extrude.h 4 | * 5 | * FUNCTION: 6 | * prototypes for privately used subroutines for the tubing library 7 | * 8 | * HISTORY: 9 | * Linas Vepstas 1991 10 | */ 11 | 12 | #include "port.h" /* for gleDouble */ 13 | 14 | #ifndef M_PI 15 | #define M_PI 3.14159265358979323846 16 | #endif 17 | 18 | /* ============================================================ */ 19 | /* 20 | * Provides choice of calling subroutine, vs. invoking macro. 21 | * Basically, inlines the source, or not. 22 | * Trades performance for executable size. 23 | */ 24 | 25 | #define INLINE_INTERSECT 26 | #ifdef INLINE_INTERSECT 27 | #define INNERSECT(sect,p,n,v1,v2) { INTERSECT(sect,p,n,v1,v2); } 28 | #else 29 | #define INNERSECT(sect,p,n,v1,v2) intersect(sect,p,n,v1,v2) 30 | #endif /* INLINE_INTERSECT */ 31 | 32 | /* ============================================================ */ 33 | /* The folowing defines give a kludgy way of accessing the qmesh primitive */ 34 | 35 | /* 36 | #define bgntmesh _emu_qmesh_bgnqmesh 37 | #define endtmesh _emu_qmesh_endqmesh 38 | #define c3f _emu_qmesh_c3f 39 | #define n3f _emu_qmesh_n3f 40 | #define v3f _emu_qmesh_v3f 41 | */ 42 | 43 | /* ============================================================ */ 44 | 45 | extern void up_sanity_check (gleDouble up[3], /* up vector for contour */ 46 | int npoints, /* numpoints in poly-line */ 47 | gleDouble point_array[][3]); /* polyline */ 48 | 49 | 50 | extern void draw_raw_style_end_cap (int ncp, /* number of contour points */ 51 | gleDouble contour[][2], /* 2D contour */ 52 | gleDouble zval, /* where to draw cap */ 53 | int frontwards); /* front or back cap */ 54 | 55 | extern void draw_round_style_cap_callback (int iloop, 56 | double cap[][3], 57 | float face_color[3], 58 | gleDouble cut_vector[3], 59 | gleDouble bisect_vector[3], 60 | double norms[][3], 61 | int frontwards); 62 | 63 | extern void draw_angle_style_front_cap (int ncp, 64 | gleDouble bi[3], 65 | gleDouble point_array[][3]); 66 | 67 | extern void extrusion_raw_join (int ncp, /* number of contour points */ 68 | gleDouble contour[][2], /* 2D contour */ 69 | gleDouble cont_normal[][2],/* 2D contour normal vecs */ 70 | gleDouble up[3], /* up vector for contour */ 71 | int npoints, /* numpoints in poly-line */ 72 | gleDouble point_array[][3], /* polyline */ 73 | float color_array[][3], /* color of polyline */ 74 | gleDouble xform_array[][2][3]); /* 2D contour xforms */ 75 | 76 | 77 | extern void extrusion_round_or_cut_join (int ncp, /* number of contour points */ 78 | gleDouble contour[][2], /* 2D contour */ 79 | gleDouble cont_normal[][2],/* 2D contour normal vecs */ 80 | gleDouble up[3], /* up vector for contour */ 81 | int npoints, /* numpoints in poly-line */ 82 | gleDouble point_array[][3], /* polyline */ 83 | float color_array[][3], /* color of polyline */ 84 | gleDouble xform_array[][2][3]); /* 2D contour xforms */ 85 | 86 | 87 | extern void extrusion_angle_join (int ncp, /* number of contour points */ 88 | gleDouble contour[][2], /* 2D contour */ 89 | gleDouble cont_normal[][2],/* 2D contour normal vecs */ 90 | gleDouble up[3], /* up vector for contour */ 91 | int npoints, /* numpoints in poly-line */ 92 | gleDouble point_array[][3], /* polyline */ 93 | float color_array[][3], /* color of polyline */ 94 | gleDouble xform_array[][2][3]); /* 2D contour xforms */ 95 | 96 | /* -------------------------- end of file -------------------------------- */ 97 | -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Headers/glsmap.h: -------------------------------------------------------------------------------- 1 | #ifndef __glsmap_h__ 2 | #define __glsmap_h__ 3 | 4 | /* Copyright (c) Mark J. Kilgard, 1998. */ 5 | 6 | /* This program is freely distributable without licensing fees 7 | and is provided without guarantee or warrantee expressed or 8 | implied. This program is -not- in the public domain. */ 9 | 10 | #if defined(_WIN32) 11 | 12 | /* Try hard to avoid including to avoid name space pollution, 13 | but Win32's needs APIENTRY and WINGDIAPI defined properly. */ 14 | # if 0 15 | # define WIN32_LEAN_AND_MEAN 16 | # include 17 | # else 18 | /* XXX This is from Win32's */ 19 | # ifndef APIENTRY 20 | # if (_MSC_VER >= 800) || defined(_STDCALL_SUPPORTED) 21 | # define APIENTRY __stdcall 22 | # else 23 | # define APIENTRY 24 | # endif 25 | # endif 26 | # ifndef CALLBACK 27 | /* XXX This is from Win32's */ 28 | # if (defined(_M_MRX000) || defined(_M_IX86) || defined(_M_ALPHA) || defined(_M_PPC)) && !defined(MIDL_PASS) 29 | # define CALLBACK __stdcall 30 | # else 31 | # define CALLBACK 32 | # endif 33 | # endif 34 | /* XXX This is from Win32's and */ 35 | # ifndef WINGDIAPI 36 | # define WINGDIAPI __declspec(dllimport) 37 | # endif 38 | /* XXX This is from Win32's */ 39 | # ifndef _WCHAR_T_DEFINED 40 | typedef unsigned short wchar_t; 41 | # define _WCHAR_T_DEFINED 42 | # endif 43 | # endif 44 | 45 | #pragma warning (disable:4244) /* Disable bogus conversion warnings. */ 46 | #pragma warning (disable:4305) /* VC++ 5.0 version of above warning. */ 47 | 48 | #endif /* _WIN32 */ 49 | 50 | #include 51 | 52 | #ifdef __cplusplus 53 | extern "C" { 54 | #endif 55 | 56 | typedef enum { 57 | SMAP_CLEAR_SMAP_TEXTURE = 0x1, 58 | SMAP_GENERATE_VIEW_MIPMAPS = 0x2, 59 | SMAP_GENERATE_SMAP_MIPMAPS = 0x4, 60 | SMAP_GENERATE_MIPMAPS = 0x6 /* both of above */ 61 | } SphereMapFlags; 62 | 63 | /* Cube view enumerants. */ 64 | enum { 65 | SMAP_FRONT = 0, 66 | SMAP_TOP = 1, 67 | SMAP_BOTTOM = 2, 68 | SMAP_LEFT = 3, 69 | SMAP_RIGHT = 4, 70 | SMAP_BACK = 5 71 | }; 72 | 73 | typedef struct _SphereMap SphereMap; 74 | 75 | extern SphereMap *smapCreateSphereMap(SphereMap *shareSmap); 76 | extern void smapDestroySphereMap(SphereMap *smap); 77 | 78 | extern void smapConfigureSphereMapMesh(SphereMap *smap, int steps, int rings, int edgeExtend); 79 | 80 | extern void smapSetSphereMapTexObj(SphereMap *smap, GLuint texobj); 81 | extern void smapSetViewTexObj(SphereMap *smap, GLuint texobj); 82 | extern void smapSetViewTexObjs(SphereMap *smap, GLuint texobjs[6]); 83 | extern void smapGetSphereMapTexObj(SphereMap *smap, GLuint *texobj); 84 | extern void smapGetViewTexObj(SphereMap *smap, GLuint *texobj); 85 | extern void smapGetViewTexObjs(SphereMap *smap, GLuint texobjs[6]); 86 | 87 | extern void smapSetFlags(SphereMap *smap, SphereMapFlags flags); 88 | extern void smapGetFlags(SphereMap *smap, SphereMapFlags *flags); 89 | 90 | extern void smapSetViewOrigin(SphereMap *smap, GLint x, GLint y); 91 | extern void smapSetSphereMapOrigin(SphereMap *smap, GLint x, GLint y); 92 | extern void smapGetViewOrigin(SphereMap *smap, GLint *x, GLint *y); 93 | extern void smapGetSphereMapOrigin(SphereMap *smap, GLint *x, GLint *y); 94 | 95 | extern void smapSetEye(SphereMap *smap, GLfloat eyex, GLfloat eyey, GLfloat eyez); 96 | extern void smapSetEyeVector(SphereMap *smap, GLfloat *eye); 97 | extern void smapSetUp(SphereMap *smap, GLfloat upx, GLfloat upy, GLfloat upz); 98 | extern void smapSetUpVector(SphereMap *smap, GLfloat *up); 99 | extern void smapSetObject(SphereMap *smap, GLfloat objx, GLfloat objy, GLfloat objz); 100 | extern void smapSetObjectVector(SphereMap *smap, GLfloat *obj); 101 | extern void smapGetEye(SphereMap *smap, GLfloat *eyex, GLfloat *eyey, GLfloat *eyez); 102 | extern void smapGetEyeVector(SphereMap *smap, GLfloat *eye); 103 | extern void smapGetUp(SphereMap *smap, GLfloat *upx, GLfloat *upy, GLfloat *upz); 104 | extern void smapGetUpVector(SphereMap *smap, GLfloat *up); 105 | extern void smapGetObject(SphereMap *smap, GLfloat *objx, GLfloat *objy, GLfloat *objz); 106 | extern void smapGetObjectVector(SphereMap *smap, GLfloat *obj); 107 | 108 | extern void smapSetNearFar(SphereMap *smap, GLfloat viewNear, GLfloat viewFar); 109 | extern void smapGetNearFar(SphereMap *smap, GLfloat *viewNear, GLfloat *viewFar); 110 | 111 | extern void smapSetSphereMapTexDim(SphereMap *smap, GLsizei texdim); 112 | extern void smapSetViewTexDim(SphereMap *smap, GLsizei texdim); 113 | extern void smapGetSphereMapTexDim(SphereMap *smap, GLsizei *texdim); 114 | extern void smapGetViewTexDim(SphereMap *smap, GLsizei *texdim); 115 | 116 | extern void smapSetContextData(SphereMap *smap, void *context); 117 | extern void smapGetContextData(SphereMap *smap, void **context); 118 | 119 | extern void smapSetPositionLightsFunc(SphereMap *smap, void (*positionLights)(int view, void *context)); 120 | extern void smapSetDrawViewFunc(SphereMap *smap, void (*drawView)(int view, void *context)); 121 | extern void smapGetPositionLightsFunc(SphereMap *smap, void (**positionLights)(int view, void *context)); 122 | extern void smapGetDrawViewFunc(SphereMap *smap, void (**drawView)(int view, void *context)); 123 | 124 | extern void smapGenViewTex(SphereMap *smap, int view); 125 | extern void smapGenViewTexs(SphereMap *smap); 126 | extern void smapGenSphereMapFromViewTexs(SphereMap *smap); 127 | extern void smapGenSphereMap(SphereMap *smap); 128 | extern void smapGenSphereMapWithOneViewTex(SphereMap *smap); 129 | 130 | extern int smapRvecToSt(float rvec[3], float st[2]); 131 | extern void smapStToRvec(float *st, float *rvec); 132 | 133 | #ifdef __cplusplus 134 | } 135 | 136 | #endif 137 | #endif /* __glsmap_h__ */ 138 | -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Headers/glsmapint.h: -------------------------------------------------------------------------------- 1 | #ifndef __glsmapint_h__ 2 | #define __glsmapint_h__ 3 | 4 | /* Copyright (c) Mark J. Kilgard, 1998. */ 5 | 6 | /* This program is freely distributable without licensing fees 7 | and is provided without guarantee or warrantee expressed or 8 | implied. This program is -not- in the public domain. */ 9 | 10 | #include "glsmap.h" 11 | 12 | enum { X = 0, Y = 1, Z = 2 }; 13 | 14 | #define INITFACE(mesh) \ 15 | int steps = mesh->steps; \ 16 | int sqsteps = mesh->steps * mesh->steps 17 | 18 | #define FACE(side,y,x) \ 19 | mesh->face[(side)*sqsteps + (y)*steps + (x)] 20 | 21 | #define FACExy(side,i,j) \ 22 | (&FACE(side,i,j).x) 23 | 24 | #define FACEst(side,i,j) \ 25 | (&FACE(side,i,j).s) 26 | 27 | #define INITBACK(mesh) \ 28 | int allrings = mesh->rings + mesh->edgeExtend; \ 29 | int ringedspokes = allrings * mesh->steps 30 | 31 | #define BACK(edge,ring,spoke) \ 32 | mesh->back[(edge)*ringedspokes + (ring)*mesh->steps + (spoke)] 33 | 34 | #define BACKxy(edge,ring,spoke) \ 35 | (&BACK(edge,ring,spoke).x) 36 | 37 | #define BACKst(edge,ring,spoke) \ 38 | (&BACK(edge,ring,spoke).s) 39 | 40 | typedef struct _STXY { 41 | GLfloat s, t; 42 | GLfloat x, y; 43 | } STXY; 44 | 45 | typedef struct _SphereMapMesh { 46 | 47 | int refcnt; 48 | 49 | int steps; 50 | int rings; 51 | int edgeExtend; 52 | 53 | STXY *face; 54 | STXY *back; 55 | 56 | } SphereMapMesh; 57 | 58 | struct _SphereMap { 59 | 60 | /* Shared sphere map mesh vertex data. */ 61 | SphereMapMesh *mesh; 62 | 63 | /* Texture object ids. */ 64 | GLuint smapTexObj; 65 | GLuint viewTexObjs[6]; 66 | GLuint viewTexObj; 67 | 68 | /* Flags */ 69 | SphereMapFlags flags; 70 | 71 | /* Texture dimensions must be a power of two. */ 72 | int viewTexDim; /* view texture dimension */ 73 | int smapTexDim; /* sphere map texture dimension */ 74 | 75 | /* Viewport origins for view and sphere map rendering. */ 76 | int viewOrigin[2]; 77 | int smapOrigin[2]; 78 | 79 | /* Viewing vectors. */ 80 | GLfloat eye[3]; 81 | GLfloat up[3]; 82 | GLfloat obj[3]; 83 | 84 | /* Projection parameters. */ 85 | GLfloat viewNear; 86 | GLfloat viewFar; 87 | 88 | /* Rendering callbacks. */ 89 | void (*positionLights)(int view, void *context); 90 | void (*drawView)(int view, void *context); 91 | 92 | /* Application specified callback data. */ 93 | void *context; 94 | 95 | }; 96 | 97 | /* Library internal routines. */ 98 | extern void __smapDrawSphereMapMeshSide(SphereMapMesh *mesh, int side); 99 | extern void __smapDrawSphereMapMeshBack(SphereMapMesh *mesh); 100 | extern void __smapValidateSphereMapMesh(SphereMapMesh *mesh); 101 | 102 | #endif /* __glsmapint_h__ */ 103 | -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Headers/glut.h: -------------------------------------------------------------------------------- 1 | #ifndef __glut_h__ 2 | #define __glut_h__ 3 | 4 | /* Copyright (c) Mark J. Kilgard, 1994, 1995, 1996, 1998. */ 5 | 6 | /* This program is freely distributable without licensing fees and is 7 | provided without guarantee or warrantee expressed or implied. This 8 | program is -not- in the public domain. */ 9 | //#define GLUT_OF_007_HACK 10 | 11 | #if defined(_WIN32) 12 | 13 | /* GLUT 3.7 now tries to avoid including 14 | to avoid name space pollution, but Win32's 15 | needs APIENTRY and WINGDIAPI defined properly. */ 16 | # if 0 17 | # define WIN32_LEAN_AND_MEAN 18 | # include 19 | # else 20 | /* XXX This is from Win32's */ 21 | # ifndef APIENTRY 22 | # define GLUT_APIENTRY_DEFINED 23 | # if (_MSC_VER >= 800) || defined(_STDCALL_SUPPORTED) 24 | # define APIENTRY __stdcall 25 | # else 26 | # define APIENTRY 27 | # endif 28 | # endif 29 | /* XXX This is from Win32's */ 30 | # ifndef CALLBACK 31 | # if (defined(_M_MRX000) || defined(_M_IX86) || defined(_M_ALPHA) || defined(_M_PPC)) && !defined(MIDL_PASS) 32 | # define CALLBACK __stdcall 33 | # else 34 | # define CALLBACK 35 | # endif 36 | # endif 37 | /* XXX This is from Win32's and */ 38 | # ifndef WINGDIAPI 39 | # define GLUT_WINGDIAPI_DEFINED 40 | # define WINGDIAPI __declspec(dllimport) 41 | # endif 42 | /* XXX This is from Win32's */ 43 | # ifndef _WCHAR_T_DEFINED 44 | typedef unsigned short wchar_t; 45 | # define _WCHAR_T_DEFINED 46 | # endif 47 | # endif 48 | 49 | #pragma comment (lib, "winmm.lib") /* link with Windows MultiMedia lib */ 50 | #pragma comment (lib, "opengl32.lib") /* link with Microsoft OpenGL lib */ 51 | #pragma comment (lib, "glu32.lib") /* link with OpenGL Utility lib */ 52 | #pragma comment (lib, "glut32.lib") /* link with Win32 GLUT lib */ 53 | 54 | #pragma warning (disable:4244) /* Disable bogus conversion warnings. */ 55 | #pragma warning (disable:4305) /* VC++ 5.0 version of above warning. */ 56 | 57 | #endif 58 | 59 | #if defined(__APPLE__) || defined(MACOSX) 60 | #include 61 | #include 62 | #include 63 | #else 64 | #include 65 | #include 66 | #endif 67 | 68 | /* define APIENTRY and CALLBACK to null string if we aren't on Win32 */ 69 | #if !defined(_WIN32) 70 | #define APIENTRY 71 | #define GLUT_APIENTRY_DEFINED 72 | #define CALLBACK 73 | #endif 74 | 75 | #ifdef __cplusplus 76 | extern "C" { 77 | #endif 78 | 79 | /** 80 | GLUT API revision history: 81 | 82 | GLUT_API_VERSION is updated to reflect incompatible GLUT 83 | API changes (interface changes, semantic changes, deletions, 84 | or additions). 85 | 86 | GLUT_API_VERSION=1 First public release of GLUT. 11/29/94 87 | 88 | GLUT_API_VERSION=2 Added support for OpenGL/GLX multisampling, 89 | extension. Supports new input devices like tablet, dial and button 90 | box, and Spaceball. Easy to query OpenGL extensions. 91 | 92 | GLUT_API_VERSION=3 glutMenuStatus added. 93 | 94 | GLUT_API_VERSION=4 glutInitDisplayString, glutWarpPointer, 95 | glutBitmapLength, glutStrokeLength, glutWindowStatusFunc, dynamic 96 | video resize subAPI, glutPostWindowRedisplay, glutKeyboardUpFunc, 97 | glutSpecialUpFunc, glutIgnoreKeyRepeat, glutSetKeyRepeat, 98 | glutJoystickFunc, glutForceJoystickFunc (NOT FINALIZED!). 99 | 100 | GLUT_API_VERSION=5 glutGetProcAddress (added by BrianP) 101 | **/ 102 | #ifndef GLUT_API_VERSION /* allow this to be overriden */ 103 | #define GLUT_API_VERSION 5 104 | #endif 105 | 106 | /** 107 | GLUT implementation revision history: 108 | 109 | GLUT_XLIB_IMPLEMENTATION is updated to reflect both GLUT 110 | API revisions and implementation revisions (ie, bug fixes). 111 | 112 | GLUT_XLIB_IMPLEMENTATION=1 mjk's first public release of 113 | GLUT Xlib-based implementation. 11/29/94 114 | 115 | GLUT_XLIB_IMPLEMENTATION=2 mjk's second public release of 116 | GLUT Xlib-based implementation providing GLUT version 2 117 | interfaces. 118 | 119 | GLUT_XLIB_IMPLEMENTATION=3 mjk's GLUT 2.2 images. 4/17/95 120 | 121 | GLUT_XLIB_IMPLEMENTATION=4 mjk's GLUT 2.3 images. 6/?/95 122 | 123 | GLUT_XLIB_IMPLEMENTATION=5 mjk's GLUT 3.0 images. 10/?/95 124 | 125 | GLUT_XLIB_IMPLEMENTATION=7 mjk's GLUT 3.1+ with glutWarpPoitner. 7/24/96 126 | 127 | GLUT_XLIB_IMPLEMENTATION=8 mjk's GLUT 3.1+ with glutWarpPoitner 128 | and video resize. 1/3/97 129 | 130 | GLUT_XLIB_IMPLEMENTATION=9 mjk's GLUT 3.4 release with early GLUT 4 routines. 131 | 132 | GLUT_XLIB_IMPLEMENTATION=11 Mesa 2.5's GLUT 3.6 release. 133 | 134 | GLUT_XLIB_IMPLEMENTATION=12 mjk's GLUT 3.6 release with early GLUT 4 routines + signal handling. 135 | 136 | GLUT_XLIB_IMPLEMENTATION=13 mjk's GLUT 3.7 beta with GameGLUT support. 137 | 138 | GLUT_XLIB_IMPLEMENTATION=14 mjk's GLUT 3.7 beta with f90gl friend interface. 139 | 140 | GLUT_XLIB_IMPLEMENTATION=15 mjk's GLUT 3.7 beta sync'ed with Mesa 141 | **/ 142 | #ifndef GLUT_XLIB_IMPLEMENTATION /* Allow this to be overriden. */ 143 | #define GLUT_XLIB_IMPLEMENTATION 15 144 | #endif 145 | 146 | /** 147 | MacOS X GLUT implementation revision history: 148 | 149 | GLUT_MACOSX_IMPLEMENTATION is updated to reflect MacOS X 150 | specific GLUT API revisions and implementation revisions 151 | (ie, bug fixes). 152 | 153 | GLUT_MACOSX_IMPLEMENTATION=1 glutSurfaceTexture. 154 | 155 | GLUT_MACOSX_IMPLEMENTATION=2 glutWMCloseFunc, glutCheckLoop. 156 | 157 | **/ 158 | #ifndef GLUT_MACOSX_IMPLEMENTATION /* Allow this to be overriden. */ 159 | #define GLUT_MACOSX_IMPLEMENTATION 2 160 | #endif 161 | 162 | /* Display mode bit masks. */ 163 | #define GLUT_RGB 0 164 | #define GLUT_RGBA GLUT_RGB 165 | #define GLUT_INDEX 1 166 | #define GLUT_SINGLE 0 167 | #define GLUT_DOUBLE 2 168 | #define GLUT_ACCUM 4 169 | #define GLUT_ALPHA 8 170 | #define GLUT_DEPTH 16 171 | #define GLUT_STENCIL 32 172 | #if (GLUT_API_VERSION >= 2) 173 | #define GLUT_MULTISAMPLE 128 174 | #define GLUT_STEREO 256 175 | #endif 176 | #if (GLUT_API_VERSION >= 3) 177 | #define GLUT_LUMINANCE 512 178 | #endif 179 | #define GLUT_NO_RECOVERY 1024 180 | 181 | /* Mouse buttons. */ 182 | #define GLUT_LEFT_BUTTON 0 183 | #define GLUT_MIDDLE_BUTTON 1 184 | #define GLUT_RIGHT_BUTTON 2 185 | 186 | /* Mouse button state. */ 187 | #define GLUT_DOWN 0 188 | #define GLUT_UP 1 189 | 190 | #if (GLUT_API_VERSION >= 2) 191 | /* function keys */ 192 | #define GLUT_KEY_F1 1 193 | #define GLUT_KEY_F2 2 194 | #define GLUT_KEY_F3 3 195 | #define GLUT_KEY_F4 4 196 | #define GLUT_KEY_F5 5 197 | #define GLUT_KEY_F6 6 198 | #define GLUT_KEY_F7 7 199 | #define GLUT_KEY_F8 8 200 | #define GLUT_KEY_F9 9 201 | #define GLUT_KEY_F10 10 202 | #define GLUT_KEY_F11 11 203 | #define GLUT_KEY_F12 12 204 | /* directional keys */ 205 | #define GLUT_KEY_LEFT 100 206 | #define GLUT_KEY_UP 101 207 | #define GLUT_KEY_RIGHT 102 208 | #define GLUT_KEY_DOWN 103 209 | #define GLUT_KEY_PAGE_UP 104 210 | #define GLUT_KEY_PAGE_DOWN 105 211 | #define GLUT_KEY_HOME 106 212 | #define GLUT_KEY_END 107 213 | #define GLUT_KEY_INSERT 108 214 | #endif 215 | 216 | /* Entry/exit state. */ 217 | #define GLUT_LEFT 0 218 | #define GLUT_ENTERED 1 219 | 220 | /* Menu usage state. */ 221 | #define GLUT_MENU_NOT_IN_USE 0 222 | #define GLUT_MENU_IN_USE 1 223 | 224 | /* Visibility state. */ 225 | #define GLUT_NOT_VISIBLE 0 226 | #define GLUT_VISIBLE 1 227 | 228 | /* Window status state. */ 229 | #define GLUT_HIDDEN 0 230 | #define GLUT_FULLY_RETAINED 1 231 | #define GLUT_PARTIALLY_RETAINED 2 232 | #define GLUT_FULLY_COVERED 3 233 | 234 | /* Color index component selection values. */ 235 | #define GLUT_RED 0 236 | #define GLUT_GREEN 1 237 | #define GLUT_BLUE 2 238 | 239 | /* Layers for use. */ 240 | #define GLUT_NORMAL 0 241 | #define GLUT_OVERLAY 1 242 | 243 | #if defined(_WIN32) 244 | /* Stroke font constants (use these in GLUT program). */ 245 | #define GLUT_STROKE_ROMAN ((void*)0) 246 | #define GLUT_STROKE_MONO_ROMAN ((void*)1) 247 | 248 | /* Bitmap font constants (use these in GLUT program). */ 249 | #define GLUT_BITMAP_9_BY_15 ((void*)2) 250 | #define GLUT_BITMAP_8_BY_13 ((void*)3) 251 | #define GLUT_BITMAP_TIMES_ROMAN_10 ((void*)4) 252 | #define GLUT_BITMAP_TIMES_ROMAN_24 ((void*)5) 253 | #if (GLUT_API_VERSION >= 3) 254 | #define GLUT_BITMAP_HELVETICA_10 ((void*)6) 255 | #define GLUT_BITMAP_HELVETICA_12 ((void*)7) 256 | #define GLUT_BITMAP_HELVETICA_18 ((void*)8) 257 | #endif 258 | #else 259 | /* Stroke font opaque addresses (use constants instead in source code). */ 260 | extern void *glutStrokeRoman; 261 | extern void *glutStrokeMonoRoman; 262 | 263 | /* Stroke font constants (use these in GLUT program). */ 264 | #define GLUT_STROKE_ROMAN (&glutStrokeRoman) 265 | #define GLUT_STROKE_MONO_ROMAN (&glutStrokeMonoRoman) 266 | 267 | /* Bitmap font opaque addresses (use constants instead in source code). */ 268 | extern void *glutBitmap9By15; 269 | extern void *glutBitmap8By13; 270 | extern void *glutBitmapTimesRoman10; 271 | extern void *glutBitmapTimesRoman24; 272 | extern void *glutBitmapHelvetica10; 273 | extern void *glutBitmapHelvetica12; 274 | extern void *glutBitmapHelvetica18; 275 | 276 | /* Bitmap font constants (use these in GLUT program). */ 277 | #define GLUT_BITMAP_9_BY_15 (&glutBitmap9By15) 278 | #define GLUT_BITMAP_8_BY_13 (&glutBitmap8By13) 279 | #define GLUT_BITMAP_TIMES_ROMAN_10 (&glutBitmapTimesRoman10) 280 | #define GLUT_BITMAP_TIMES_ROMAN_24 (&glutBitmapTimesRoman24) 281 | #if (GLUT_API_VERSION >= 3) 282 | #define GLUT_BITMAP_HELVETICA_10 (&glutBitmapHelvetica10) 283 | #define GLUT_BITMAP_HELVETICA_12 (&glutBitmapHelvetica12) 284 | #define GLUT_BITMAP_HELVETICA_18 (&glutBitmapHelvetica18) 285 | #endif 286 | #endif 287 | 288 | /* glutGet parameters. */ 289 | #define GLUT_WINDOW_X 100 290 | #define GLUT_WINDOW_Y 101 291 | #define GLUT_WINDOW_WIDTH 102 292 | #define GLUT_WINDOW_HEIGHT 103 293 | #define GLUT_WINDOW_BUFFER_SIZE 104 294 | #define GLUT_WINDOW_STENCIL_SIZE 105 295 | #define GLUT_WINDOW_DEPTH_SIZE 106 296 | #define GLUT_WINDOW_RED_SIZE 107 297 | #define GLUT_WINDOW_GREEN_SIZE 108 298 | #define GLUT_WINDOW_BLUE_SIZE 109 299 | #define GLUT_WINDOW_ALPHA_SIZE 110 300 | #define GLUT_WINDOW_ACCUM_RED_SIZE 111 301 | #define GLUT_WINDOW_ACCUM_GREEN_SIZE 112 302 | #define GLUT_WINDOW_ACCUM_BLUE_SIZE 113 303 | #define GLUT_WINDOW_ACCUM_ALPHA_SIZE 114 304 | #define GLUT_WINDOW_DOUBLEBUFFER 115 305 | #define GLUT_WINDOW_RGBA 116 306 | #define GLUT_WINDOW_PARENT 117 307 | #define GLUT_WINDOW_NUM_CHILDREN 118 308 | #define GLUT_WINDOW_COLORMAP_SIZE 119 309 | #if (GLUT_API_VERSION >= 2) 310 | #define GLUT_WINDOW_NUM_SAMPLES 120 311 | #define GLUT_WINDOW_STEREO 121 312 | #endif 313 | #if (GLUT_API_VERSION >= 3) 314 | #define GLUT_WINDOW_CURSOR 122 315 | #endif 316 | #define GLUT_SCREEN_WIDTH 200 317 | #define GLUT_SCREEN_HEIGHT 201 318 | #define GLUT_SCREEN_WIDTH_MM 202 319 | #define GLUT_SCREEN_HEIGHT_MM 203 320 | #define GLUT_MENU_NUM_ITEMS 300 321 | #define GLUT_DISPLAY_MODE_POSSIBLE 400 322 | #define GLUT_INIT_WINDOW_X 500 323 | #define GLUT_INIT_WINDOW_Y 501 324 | #define GLUT_INIT_WINDOW_WIDTH 502 325 | #define GLUT_INIT_WINDOW_HEIGHT 503 326 | #define GLUT_INIT_DISPLAY_MODE 504 327 | #if (GLUT_API_VERSION >= 2) 328 | #define GLUT_ELAPSED_TIME 700 329 | #endif 330 | #if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 13) 331 | #define GLUT_WINDOW_FORMAT_ID 123 332 | #endif 333 | 334 | #if (GLUT_API_VERSION >= 2) 335 | /* glutDeviceGet parameters. */ 336 | #define GLUT_HAS_KEYBOARD 600 337 | #define GLUT_HAS_MOUSE 601 338 | #define GLUT_HAS_SPACEBALL 602 339 | #define GLUT_HAS_DIAL_AND_BUTTON_BOX 603 340 | #define GLUT_HAS_TABLET 604 341 | #define GLUT_NUM_MOUSE_BUTTONS 605 342 | #define GLUT_NUM_SPACEBALL_BUTTONS 606 343 | #define GLUT_NUM_BUTTON_BOX_BUTTONS 607 344 | #define GLUT_NUM_DIALS 608 345 | #define GLUT_NUM_TABLET_BUTTONS 609 346 | #endif 347 | #if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 13) 348 | #define GLUT_DEVICE_IGNORE_KEY_REPEAT 610 349 | #define GLUT_DEVICE_KEY_REPEAT 611 350 | #define GLUT_HAS_JOYSTICK 612 351 | #define GLUT_OWNS_JOYSTICK 613 352 | #define GLUT_JOYSTICK_BUTTONS 614 353 | #define GLUT_JOYSTICK_AXES 615 354 | #define GLUT_JOYSTICK_POLL_RATE 616 355 | #endif 356 | 357 | #if (GLUT_API_VERSION >= 3) 358 | /* glutLayerGet parameters. */ 359 | #define GLUT_OVERLAY_POSSIBLE 800 360 | #define GLUT_LAYER_IN_USE 801 361 | #define GLUT_HAS_OVERLAY 802 362 | #define GLUT_TRANSPARENT_INDEX 803 363 | #define GLUT_NORMAL_DAMAGED 804 364 | #define GLUT_OVERLAY_DAMAGED 805 365 | 366 | #if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9) 367 | /* glutVideoResizeGet parameters. */ 368 | #define GLUT_VIDEO_RESIZE_POSSIBLE 900 369 | #define GLUT_VIDEO_RESIZE_IN_USE 901 370 | #define GLUT_VIDEO_RESIZE_X_DELTA 902 371 | #define GLUT_VIDEO_RESIZE_Y_DELTA 903 372 | #define GLUT_VIDEO_RESIZE_WIDTH_DELTA 904 373 | #define GLUT_VIDEO_RESIZE_HEIGHT_DELTA 905 374 | #define GLUT_VIDEO_RESIZE_X 906 375 | #define GLUT_VIDEO_RESIZE_Y 907 376 | #define GLUT_VIDEO_RESIZE_WIDTH 908 377 | #define GLUT_VIDEO_RESIZE_HEIGHT 909 378 | #endif 379 | 380 | /* glutUseLayer parameters. */ 381 | #define GLUT_NORMAL 0 382 | #define GLUT_OVERLAY 1 383 | 384 | /* glutGetModifiers return mask. */ 385 | #define GLUT_ACTIVE_SHIFT 1 386 | #define GLUT_ACTIVE_CTRL 2 387 | #define GLUT_ACTIVE_ALT 4 388 | 389 | /* glutSetCursor parameters. */ 390 | /* Basic arrows. */ 391 | #define GLUT_CURSOR_RIGHT_ARROW 0 392 | #define GLUT_CURSOR_LEFT_ARROW 1 393 | /* Symbolic cursor shapes. */ 394 | #define GLUT_CURSOR_INFO 2 395 | #define GLUT_CURSOR_DESTROY 3 396 | #define GLUT_CURSOR_HELP 4 397 | #define GLUT_CURSOR_CYCLE 5 398 | #define GLUT_CURSOR_SPRAY 6 399 | #define GLUT_CURSOR_WAIT 7 400 | #define GLUT_CURSOR_TEXT 8 401 | #define GLUT_CURSOR_CROSSHAIR 9 402 | /* Directional cursors. */ 403 | #define GLUT_CURSOR_UP_DOWN 10 404 | #define GLUT_CURSOR_LEFT_RIGHT 11 405 | /* Sizing cursors. */ 406 | #define GLUT_CURSOR_TOP_SIDE 12 407 | #define GLUT_CURSOR_BOTTOM_SIDE 13 408 | #define GLUT_CURSOR_LEFT_SIDE 14 409 | #define GLUT_CURSOR_RIGHT_SIDE 15 410 | #define GLUT_CURSOR_TOP_LEFT_CORNER 16 411 | #define GLUT_CURSOR_TOP_RIGHT_CORNER 17 412 | #define GLUT_CURSOR_BOTTOM_RIGHT_CORNER 18 413 | #define GLUT_CURSOR_BOTTOM_LEFT_CORNER 19 414 | /* Inherit from parent window. */ 415 | #define GLUT_CURSOR_INHERIT 100 416 | /* Blank cursor. */ 417 | #define GLUT_CURSOR_NONE 101 418 | /* Fullscreen crosshair (if available). */ 419 | #define GLUT_CURSOR_FULL_CROSSHAIR 102 420 | #endif 421 | 422 | /* GLUT initialization sub-API. */ 423 | extern void APIENTRY glutInit(int *argcp, char **argv); 424 | extern void APIENTRY glutInitDisplayMode(unsigned int mode); 425 | #if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9) 426 | extern void APIENTRY glutInitDisplayString(const char *string); 427 | #endif 428 | extern void APIENTRY glutInitWindowPosition(int x, int y); 429 | extern void APIENTRY glutInitWindowSize(int width, int height); 430 | extern void APIENTRY glutMainLoop(void); 431 | 432 | /* GLUT window sub-API. */ 433 | extern int APIENTRY glutCreateWindow(const char *title); 434 | extern int APIENTRY glutCreateSubWindow(int win, int x, int y, int width, int height); 435 | extern void APIENTRY glutDestroyWindow(int win); 436 | extern void APIENTRY glutPostRedisplay(void); 437 | #if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 11) 438 | extern void APIENTRY glutPostWindowRedisplay(int win); 439 | #endif 440 | extern void APIENTRY glutSwapBuffers(void); 441 | extern int APIENTRY glutGetWindow(void); 442 | extern void APIENTRY glutSetWindow(int win); 443 | extern void APIENTRY glutSetWindowTitle(const char *title); 444 | extern void APIENTRY glutSetIconTitle(const char *title); 445 | extern void APIENTRY glutPositionWindow(int x, int y); 446 | extern void APIENTRY glutReshapeWindow(int width, int height); 447 | extern void APIENTRY glutPopWindow(void); 448 | extern void APIENTRY glutPushWindow(void); 449 | extern void APIENTRY glutIconifyWindow(void); 450 | extern void APIENTRY glutShowWindow(void); 451 | extern void APIENTRY glutHideWindow(void); 452 | #if (GLUT_API_VERSION >= 3) 453 | extern void APIENTRY glutFullScreen(void); 454 | extern void APIENTRY glutSetCursor(int cursor); 455 | #if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9) 456 | extern void APIENTRY glutWarpPointer(int x, int y); 457 | #if (GLUT_MACOSX_IMPLEMENTATION >= 1) 458 | /* surface texturing API Mac OS X specific 459 | * Note: 460 | * glutSurfaceTexture has been deprecated, use GL_EXT_framebuffer_object 461 | */ 462 | #ifdef MAC_OS_X_VERSION_10_5 463 | extern void APIENTRY glutSurfaceTexture (GLenum target, GLenum internalformat, int surfacewin); AVAILABLE_MAC_OS_X_VERSION_10_2_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_5 464 | #else 465 | extern void APIENTRY glutSurfaceTexture (GLenum target, GLenum internalformat, int surfacewin); 466 | #endif 467 | #endif 468 | #if (GLUT_MACOSX_IMPLEMENTATION >= 2) 469 | /* Mac OS X specific API */ 470 | extern void APIENTRY glutWMCloseFunc(void (*func)(void)); 471 | extern void APIENTRY glutCheckLoop(void); 472 | #endif 473 | #endif 474 | 475 | /* GLUT overlay sub-API. */ 476 | extern void APIENTRY glutEstablishOverlay(void); 477 | extern void APIENTRY glutRemoveOverlay(void); 478 | extern void APIENTRY glutUseLayer(GLenum layer); 479 | extern void APIENTRY glutPostOverlayRedisplay(void); 480 | #if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 11) 481 | extern void APIENTRY glutPostWindowOverlayRedisplay(int win); 482 | #endif 483 | extern void APIENTRY glutShowOverlay(void); 484 | extern void APIENTRY glutHideOverlay(void); 485 | #endif 486 | 487 | /* GLUT menu sub-API. */ 488 | extern int APIENTRY glutCreateMenu(void (*)(int)); 489 | extern void APIENTRY glutDestroyMenu(int menu); 490 | extern int APIENTRY glutGetMenu(void); 491 | extern void APIENTRY glutSetMenu(int menu); 492 | extern void APIENTRY glutAddMenuEntry(const char *label, int value); 493 | extern void APIENTRY glutAddSubMenu(const char *label, int submenu); 494 | extern void APIENTRY glutChangeToMenuEntry(int item, const char *label, int value); 495 | extern void APIENTRY glutChangeToSubMenu(int item, const char *label, int submenu); 496 | extern void APIENTRY glutRemoveMenuItem(int item); 497 | extern void APIENTRY glutAttachMenu(int button); 498 | extern void APIENTRY glutDetachMenu(int button); 499 | 500 | /* GLUT window callback sub-API. */ 501 | extern void APIENTRY glutDisplayFunc(void (*func)(void)); 502 | extern void APIENTRY glutReshapeFunc(void (*func)(int width, int height)); 503 | extern void APIENTRY glutKeyboardFunc(void (*func)(unsigned char key, int x, int y)); 504 | extern void APIENTRY glutMouseFunc(void (*func)(int button, int state, int x, int y)); 505 | extern void APIENTRY glutMotionFunc(void (*func)(int x, int y)); 506 | extern void APIENTRY glutPassiveMotionFunc(void (*func)(int x, int y)); 507 | extern void APIENTRY glutEntryFunc(void (*func)(int state)); 508 | extern void APIENTRY glutVisibilityFunc(void (*func)(int state)); 509 | extern void APIENTRY glutIdleFunc(void (*func)(void)); 510 | extern void APIENTRY glutTimerFunc(unsigned int millis, void (*func)(int value), int value); 511 | extern void APIENTRY glutMenuStateFunc(void (*func)(int state)); 512 | #if (GLUT_API_VERSION >= 2) 513 | extern void APIENTRY glutSpecialFunc(void (*func)(int key, int x, int y)); 514 | extern void APIENTRY glutSpaceballMotionFunc(void (*func)(int x, int y, int z)); 515 | extern void APIENTRY glutSpaceballRotateFunc(void (*func)(int x, int y, int z)); 516 | extern void APIENTRY glutSpaceballButtonFunc(void (*func)(int button, int state)); 517 | extern void APIENTRY glutButtonBoxFunc(void (*func)(int button, int state)); 518 | extern void APIENTRY glutDialsFunc(void (*func)(int dial, int value)); 519 | extern void APIENTRY glutTabletMotionFunc(void (*func)(int x, int y)); 520 | extern void APIENTRY glutTabletButtonFunc(void (*func)(int button, int state, int x, int y)); 521 | #if (GLUT_API_VERSION >= 3) 522 | extern void APIENTRY glutMenuStatusFunc(void (*func)(int status, int x, int y)); 523 | extern void APIENTRY glutOverlayDisplayFunc(void (*func)(void)); 524 | #if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9) 525 | extern void APIENTRY glutWindowStatusFunc(void (*func)(int state)); 526 | #endif 527 | #if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 13) 528 | extern void APIENTRY glutKeyboardUpFunc(void (*func)(unsigned char key, int x, int y)); 529 | extern void APIENTRY glutSpecialUpFunc(void (*func)(int key, int x, int y)); 530 | extern void APIENTRY glutJoystickFunc(void (*func)(unsigned int buttonMask, int x, int y, int z), int pollInterval); 531 | //#ifdef GLUT_OF_007_HACK 532 | extern void APIENTRY glutDragEventFunc(void (*func)(char ** fileNames, int nFiles, int dragX, int dragY)); 533 | //#endif 534 | #endif 535 | #endif 536 | #endif 537 | 538 | /* GLUT color index sub-API. */ 539 | extern void APIENTRY glutSetColor(int, GLfloat red, GLfloat green, GLfloat blue); 540 | extern GLfloat APIENTRY glutGetColor(int ndx, int component); 541 | extern void APIENTRY glutCopyColormap(int win); 542 | 543 | /* GLUT state retrieval sub-API. */ 544 | extern int APIENTRY glutGet(GLenum type); 545 | extern int APIENTRY glutDeviceGet(GLenum type); 546 | #if (GLUT_API_VERSION >= 2) 547 | /* GLUT extension support sub-API */ 548 | extern int APIENTRY glutExtensionSupported(const char *name); 549 | #endif 550 | #if (GLUT_API_VERSION >= 3) 551 | extern int APIENTRY glutGetModifiers(void); 552 | extern int APIENTRY glutLayerGet(GLenum type); 553 | #endif 554 | #if (GLUT_API_VERSION >= 5) 555 | extern void * APIENTRY glutGetProcAddress(const char *procName); 556 | #endif 557 | 558 | /* GLUT font sub-API */ 559 | extern void APIENTRY glutBitmapCharacter(void *font, int character); 560 | extern int APIENTRY glutBitmapWidth(void *font, int character); 561 | extern void APIENTRY glutStrokeCharacter(void *font, int character); 562 | extern int APIENTRY glutStrokeWidth(void *font, int character); 563 | #if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9) 564 | extern int APIENTRY glutBitmapLength(void *font, const unsigned char *string); 565 | extern int APIENTRY glutStrokeLength(void *font, const unsigned char *string); 566 | #endif 567 | 568 | /* GLUT pre-built models sub-API */ 569 | extern void APIENTRY glutWireSphere(GLdouble radius, GLint slices, GLint stacks); 570 | extern void APIENTRY glutSolidSphere(GLdouble radius, GLint slices, GLint stacks); 571 | extern void APIENTRY glutWireCone(GLdouble base, GLdouble height, GLint slices, GLint stacks); 572 | extern void APIENTRY glutSolidCone(GLdouble base, GLdouble height, GLint slices, GLint stacks); 573 | extern void APIENTRY glutWireCube(GLdouble size); 574 | extern void APIENTRY glutSolidCube(GLdouble size); 575 | extern void APIENTRY glutWireTorus(GLdouble innerRadius, GLdouble outerRadius, GLint sides, GLint rings); 576 | extern void APIENTRY glutSolidTorus(GLdouble innerRadius, GLdouble outerRadius, GLint sides, GLint rings); 577 | extern void APIENTRY glutWireDodecahedron(void); 578 | extern void APIENTRY glutSolidDodecahedron(void); 579 | extern void APIENTRY glutWireTeapot(GLdouble size); 580 | extern void APIENTRY glutSolidTeapot(GLdouble size); 581 | extern void APIENTRY glutWireOctahedron(void); 582 | extern void APIENTRY glutSolidOctahedron(void); 583 | extern void APIENTRY glutWireTetrahedron(void); 584 | extern void APIENTRY glutSolidTetrahedron(void); 585 | extern void APIENTRY glutWireIcosahedron(void); 586 | extern void APIENTRY glutSolidIcosahedron(void); 587 | 588 | #if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9) 589 | /* GLUT video resize sub-API. */ 590 | extern int APIENTRY glutVideoResizeGet(GLenum param); 591 | extern void APIENTRY glutSetupVideoResizing(void); 592 | extern void APIENTRY glutStopVideoResizing(void); 593 | extern void APIENTRY glutVideoResize(int x, int y, int width, int height); 594 | extern void APIENTRY glutVideoPan(int x, int y, int width, int height); 595 | 596 | /* GLUT debugging sub-API. */ 597 | extern void APIENTRY glutReportErrors(void); 598 | #endif 599 | 600 | #if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 13) 601 | /* GLUT device control sub-API. */ 602 | /* glutSetKeyRepeat modes. */ 603 | #define GLUT_KEY_REPEAT_OFF 0 604 | #define GLUT_KEY_REPEAT_ON 1 605 | #define GLUT_KEY_REPEAT_DEFAULT 2 606 | 607 | /* Joystick button masks. */ 608 | #define GLUT_JOYSTICK_BUTTON_A 1 609 | #define GLUT_JOYSTICK_BUTTON_B 2 610 | #define GLUT_JOYSTICK_BUTTON_C 4 611 | #define GLUT_JOYSTICK_BUTTON_D 8 612 | 613 | extern void APIENTRY glutIgnoreKeyRepeat(int ignore); 614 | extern void APIENTRY glutSetKeyRepeat(int repeatMode); 615 | extern void APIENTRY glutForceJoystickFunc(void); 616 | 617 | /* GLUT game mode sub-API. */ 618 | /* glutGameModeGet. */ 619 | #define GLUT_GAME_MODE_ACTIVE 0 620 | #define GLUT_GAME_MODE_POSSIBLE 1 621 | #define GLUT_GAME_MODE_WIDTH 2 622 | #define GLUT_GAME_MODE_HEIGHT 3 623 | #define GLUT_GAME_MODE_PIXEL_DEPTH 4 624 | #define GLUT_GAME_MODE_REFRESH_RATE 5 625 | #define GLUT_GAME_MODE_DISPLAY_CHANGED 6 626 | 627 | extern void APIENTRY glutGameModeString(const char *string); 628 | extern int APIENTRY glutEnterGameMode(void); 629 | extern void APIENTRY glutLeaveGameMode(void); 630 | extern int APIENTRY glutGameModeGet(GLenum mode); 631 | #endif 632 | 633 | #ifdef __cplusplus 634 | } 635 | 636 | #endif 637 | 638 | #ifdef GLUT_APIENTRY_DEFINED 639 | # undef GLUT_APIENTRY_DEFINED 640 | # undef APIENTRY 641 | #endif 642 | 643 | #ifdef GLUT_WINGDIAPI_DEFINED 644 | # undef GLUT_WINGDIAPI_DEFINED 645 | # undef WINGDIAPI 646 | #endif 647 | 648 | #endif /* __glut_h__ */ 649 | -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Headers/glutbitmap.h: -------------------------------------------------------------------------------- 1 | #ifndef __glutbitmap_h__ 2 | #define __glutbitmap_h__ 3 | 4 | /* Copyright (c) Mark J. Kilgard, 1994. */ 5 | 6 | /* This program is freely distributable without licensing fees 7 | and is provided without guarantee or warrantee expressed or 8 | implied. This program is -not- in the public domain. */ 9 | 10 | #include "glut.h" 11 | 12 | typedef struct { 13 | const GLsizei width; 14 | const GLsizei height; 15 | const GLfloat xorig; 16 | const GLfloat yorig; 17 | const GLfloat advance; 18 | const GLubyte *bitmap; 19 | } BitmapCharRec, *BitmapCharPtr; 20 | 21 | typedef struct { 22 | const char *name; 23 | const int num_chars; 24 | const int first; 25 | const BitmapCharRec * const *ch; 26 | } BitmapFontRec, *BitmapFontPtr; 27 | 28 | typedef void *GLUTbitmapFont; 29 | 30 | #endif /* __glutbitmap_h__ */ 31 | -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Headers/glutf90.h: -------------------------------------------------------------------------------- 1 | #ifndef __glutf90_h__ 2 | #define __glutf90_h__ 3 | 4 | /* Copyright (c) Mark J. Kilgard & Willam F. Mitchell, 1998. */ 5 | 6 | /* This program is freely distributable without licensing fees 7 | and is provided without guarantee or warrantee expressed or 8 | implied. This program is -not- in the public domain. */ 9 | 10 | /* This header provides the binding interface for William Mitchell's 11 | f90gl Fortran 90 GLUT binding. Other GLUT language bindings 12 | can and should use this interace. */ 13 | 14 | /* I appreciate the guidance from William Mitchell 15 | (mitchell@cam.nist.gov) in developing this friend interface 16 | for use by the f90gl package. See ../../README.fortran */ 17 | 18 | #include 19 | 20 | #ifndef GLUTCALLBACK 21 | #define GLUTCALLBACK 22 | #endif 23 | #ifndef APIENTRY 24 | #define APIENTRY 25 | #endif 26 | 27 | /* Which callback enumerants for the __glutSetFCB/__glutGetFCB routines. */ 28 | /* NOTE These values are part of a binary interface for the f90gl Fortran 29 | 90 binding and so must NOT changes (additions are allowed). */ 30 | 31 | /* GLUTwindow callbacks. */ 32 | #define GLUT_FCB_DISPLAY 0 /* GLUTdisplayFCB */ 33 | #define GLUT_FCB_RESHAPE 1 /* GLUTreshapeFCB */ 34 | #define GLUT_FCB_MOUSE 2 /* GLUTmouseFCB */ 35 | #define GLUT_FCB_MOTION 3 /* GLUTmotionFCB */ 36 | #define GLUT_FCB_PASSIVE 4 /* GLUTpassiveFCB */ 37 | #define GLUT_FCB_ENTRY 5 /* GLUTentryFCB */ 38 | #define GLUT_FCB_KEYBOARD 6 /* GLUTkeyboardFCB */ 39 | #define GLUT_FCB_KEYBOARD_UP 7 /* GLUTkeyboardFCB */ 40 | #define GLUT_FCB_WINDOW_STATUS 8 /* GLUTwindowStatusFCB */ 41 | #define GLUT_FCB_VISIBILITY 9 /* GLUTvisibilityFCB */ 42 | #define GLUT_FCB_SPECIAL 10 /* GLUTspecialFCB */ 43 | #define GLUT_FCB_SPECIAL_UP 11 /* GLUTspecialFCB */ 44 | #define GLUT_FCB_BUTTON_BOX 12 /* GLUTbuttonBoxFCB */ 45 | #define GLUT_FCB_DIALS 13 /* GLUTdialsFCB */ 46 | #define GLUT_FCB_SPACE_MOTION 14 /* GLUTspaceMotionFCB */ 47 | #define GLUT_FCB_SPACE_ROTATE 15 /* GLUTspaceRotateFCB */ 48 | #define GLUT_FCB_SPACE_BUTTON 16 /* GLUTspaceButtonFCB */ 49 | #define GLUT_FCB_TABLET_MOTION 17 /* GLUTtabletMotionFCB */ 50 | #define GLUT_FCB_TABLET_BUTTON 18 /* GLUTtabletButtonFCB */ 51 | #define GLUT_FCB_JOYSTICK 19 /* GLUTjoystickFCB */ 52 | #define GLUT_FCB_WMCLOSE 20 /* GLUTwmcloseFCB */ 53 | /* Non-GLUTwindow callbacks. */ 54 | #define GLUT_FCB_OVERLAY_DISPLAY 100 /* GLUTdisplayFCB */ 55 | #define GLUT_FCB_SELECT 101 /* GLUTselectFCB */ 56 | #define GLUT_FCB_TIMER 102 /* GLUTtimerFCB */ 57 | 58 | /* GLUT Fortran callback function types. */ 59 | typedef void (GLUTCALLBACK *GLUTdisplayFCB) (void); 60 | typedef void (GLUTCALLBACK *GLUTwmcloseFCB) (void); 61 | typedef void (GLUTCALLBACK *GLUTreshapeFCB) (int *, int *); 62 | /* NOTE the pressed key is int, not unsigned char for Fortran! */ 63 | typedef void (GLUTCALLBACK *GLUTkeyboardFCB) (int *, int *, int *); 64 | typedef void (GLUTCALLBACK *GLUTmouseFCB) (int *, int *, int *, int *); 65 | typedef void (GLUTCALLBACK *GLUTmotionFCB) (int *, int *); 66 | typedef void (GLUTCALLBACK *GLUTpassiveFCB) (int *, int *); 67 | typedef void (GLUTCALLBACK *GLUTentryFCB) (int *); 68 | typedef void (GLUTCALLBACK *GLUTwindowStatusFCB) (int *); 69 | typedef void (GLUTCALLBACK *GLUTvisibilityFCB) (int *); 70 | typedef void (GLUTCALLBACK *GLUTspecialFCB) (int *, int *, int *); 71 | typedef void (GLUTCALLBACK *GLUTbuttonBoxFCB) (int *, int *); 72 | typedef void (GLUTCALLBACK *GLUTdialsFCB) (int *, int *); 73 | typedef void (GLUTCALLBACK *GLUTspaceMotionFCB) (int *, int *, int *); 74 | typedef void (GLUTCALLBACK *GLUTspaceRotateFCB) (int *, int *, int *); 75 | typedef void (GLUTCALLBACK *GLUTspaceButtonFCB) (int *, int *); 76 | typedef void (GLUTCALLBACK *GLUTtabletMotionFCB) (int *, int *); 77 | typedef void (GLUTCALLBACK *GLUTtabletButtonFCB) (int *, int *, int *, int *); 78 | typedef void (GLUTCALLBACK *GLUTjoystickFCB) (unsigned int *buttonMask, int *x, int *y, int *z); 79 | 80 | typedef void (GLUTCALLBACK *GLUTselectFCB) (int *); 81 | typedef void (GLUTCALLBACK *GLUTtimerFCB) (int *); 82 | typedef void (GLUTCALLBACK *GLUTmenuStateFCB) (int *); /* DEPRICATED. */ 83 | typedef void (GLUTCALLBACK *GLUTmenuStatusFCB) (int *, int *, int *); 84 | typedef void (GLUTCALLBACK *GLUTidleFCB) (void); 85 | 86 | /* Functions that set and return Fortran callback functions. */ 87 | extern void* APIENTRY __glutGetFCB(int which); 88 | extern void APIENTRY __glutSetFCB(int which, void *func); 89 | 90 | #endif /* __glutf90_h__ */ 91 | -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Headers/glutstroke.h: -------------------------------------------------------------------------------- 1 | #ifndef __glutstroke_h__ 2 | #define __glutstroke_h__ 3 | 4 | /* Copyright (c) Mark J. Kilgard, 1994. */ 5 | 6 | /* This program is freely distributable without licensing fees 7 | and is provided without guarantee or warrantee expressed or 8 | implied. This program is -not- in the public domain. */ 9 | 10 | #if defined(_WIN32) 11 | #pragma warning (disable:4244) /* disable bogus conversion warnings */ 12 | #pragma warning (disable:4305) /* VC++ 5.0 version of above warning. */ 13 | #endif 14 | 15 | typedef struct { 16 | float x; 17 | float y; 18 | } CoordRec, *CoordPtr; 19 | 20 | typedef struct { 21 | int num_coords; 22 | const CoordRec *coord; 23 | } StrokeRec, *StrokePtr; 24 | 25 | typedef struct { 26 | int num_strokes; 27 | const StrokeRec *stroke; 28 | float center; 29 | float right; 30 | } StrokeCharRec, *StrokeCharPtr; 31 | 32 | typedef struct { 33 | const char *name; 34 | int num_chars; 35 | const StrokeCharRec *ch; 36 | float top; 37 | float bottom; 38 | } StrokeFontRec, *StrokeFontPtr; 39 | 40 | typedef void *GLUTstrokeFont; 41 | 42 | #endif /* __glutstroke_h__ */ 43 | -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Headers/gutil.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * gutil.h 4 | * 5 | * FUNCTION: 6 | * Provide utilities that allow rotation to occur 7 | * around any axis. 8 | * 9 | * HISTORY: 10 | * created by Linas Vepstas 1990 11 | * added single & double precision, June 1991, Linas Vepstas 12 | */ 13 | 14 | #ifndef __GUTIL_H__ 15 | #define __GUTIL_H__ 16 | 17 | #ifdef __GUTIL_DOUBLE 18 | #define gutDouble double 19 | #else 20 | #define gutDouble float 21 | #endif 22 | 23 | 24 | #ifdef _NO_PROTO /* NO ANSI C PROTOTYPING */ 25 | 26 | /* Rotation Utilities */ 27 | extern void rot_axis_f (); 28 | extern void rot_about_axis_f (); 29 | extern void rot_omega_f (); 30 | extern void urot_axis_f (); 31 | extern void urot_about_axis_f (); 32 | extern void urot_omega_f (); 33 | 34 | /* double-precision versions */ 35 | extern void rot_axis_d (); 36 | extern void rot_about_axis_d (); 37 | extern void rot_omega_d (); 38 | extern void urot_axis_d (); 39 | extern void urot_about_axis_d (); 40 | extern void urot_omega_d (); 41 | 42 | /* viewpoint functions */ 43 | extern void uview_direction_d (); 44 | extern void uview_direction_f (); 45 | extern void uviewpoint_d (); 46 | extern void uviewpoint_f (); 47 | 48 | #else /* _NO_PROTO */ /* ANSI C PROTOTYPING */ 49 | 50 | /* Rotation Utilities */ 51 | extern void rot_axis_f (float omega, float axis[3]); 52 | extern void rot_about_axis_f (float angle, float axis[3]); 53 | extern void rot_omega_f (float axis[3]); 54 | extern void urot_axis_f (float m[4][4], float omega, float axis[3]); 55 | extern void urot_about_axis_f (float m[4][4], float angle, float axis[3]); 56 | extern void urot_omega_f (float m[4][4], float axis[3]); 57 | 58 | /* double-precision versions */ 59 | extern void rot_axis_d (double omega, double axis[3]); 60 | extern void rot_about_axis_d (double angle, double axis[3]); 61 | extern void rot_omega_d (double axis[3]); 62 | extern void urot_axis_d (double m[4][4], double omega, double axis[3]); 63 | extern void urot_about_axis_d (double m[4][4], double angle, double axis[3]); 64 | extern void urot_omega_d (double m[4][4], double axis[3]); 65 | 66 | /* viewpoint functions */ 67 | extern void uview_direction_d (double m[4][4], /* returned */ 68 | double v21[3], /* input */ 69 | double up[3]); /* input */ 70 | 71 | extern void uview_direction_f (float m[4][4], /* returned */ 72 | float v21[3], /* input */ 73 | float up[3]); /* input */ 74 | 75 | extern void uviewpoint_d (double m[4][4], /* returned */ 76 | double v1[3], /* input */ 77 | double v2[3], /* input */ 78 | double up[3]); /* input */ 79 | 80 | extern void uviewpoint_f (float m[4][4], /* returned */ 81 | float v1[3], /* input */ 82 | float v2[3], /* input */ 83 | float up[3]); /* input */ 84 | 85 | #endif /* _NO_PROTO */ 86 | 87 | #endif /* _GUTIL_H__ */ 88 | 89 | /* ------------------- end of file ---------------------- */ 90 | -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Headers/intersect.h: -------------------------------------------------------------------------------- 1 | /* 2 | * FUNCTION: 3 | * This file contains a number of utilities useful to 3D graphics in 4 | * general, and to the generation of tubing and extrusions in particular 5 | * 6 | * HISTORY: 7 | * Written by Linas Vepstas, August 1991 8 | * Updated to correctly handle degenerate cases, Linas, February 1993 9 | */ 10 | 11 | #include 12 | #include "port.h" 13 | #include "vvector.h" 14 | 15 | #define BACKWARDS_INTERSECT (2) 16 | 17 | /* ========================================================== */ 18 | /* 19 | * the Degenerate_Tolerance token represents the greatest amount by 20 | * which different scales in a graphics environment can differ before 21 | * they should be considered "degenerate". That is, when one vector is 22 | * a million times longer than another, changces are that the second will 23 | * be less than a pixel int, and therefore was probably meant to be 24 | * degenerate (by the CAD package, etc.) But what should this tolerance 25 | * be? At least 1 in onethousand (since screen sizes are 1K pixels), but 26 | * les than 1 in 4 million (since this is the limit of single-precision 27 | * floating point accuracy). Of course, if double precision were used, 28 | * then the tolerance could be increased. 29 | * 30 | * Potentially, this naive assumption could cause problems if the CAD 31 | * package attempts to zoom in on small details, and turns out, certain 32 | * points should not hvae been degenerate. The problem presented here 33 | * is that the tolerance could run out before single-precision ran 34 | * out, and so the CAD packages would perceive this as a "bug". 35 | * One alternative is to fiddle around & try to tighten the tolerance. 36 | * However, the right alternative is to code the graphics pipeline in 37 | * double-precision (and tighten the tolerance). 38 | * 39 | * By the way, note that Degernate Tolerance is a "dimensionless" 40 | * quantitiy -- it has no units -- it does not measure feet, inches, 41 | * millimeters or pixels. It is used only in the computations of ratios 42 | * and relative lengths. 43 | */ 44 | 45 | /* 46 | * Right now, the tolerance is set to 2 parts in a million, which 47 | * corresponds to a 19-bit distinction of mantissas. Note that 48 | * single-precsion numbers have 24 bit mantissas. 49 | */ 50 | 51 | #define DEGENERATE_TOLERANCE (0.000002) 52 | 53 | /* ========================================================== */ 54 | /* 55 | * The macro and subroutine INTERSECT are designed to compute the 56 | * intersection of a line (defined by the points v1 and v2) and a plane 57 | * (defined as plane which is normal to the vector n, and contains the 58 | * point p). Both return the point sect, which is the point of 59 | * interesection. 60 | * 61 | * This MACRO attemps to be fairly robust by checking for a divide by 62 | * zero. 63 | */ 64 | 65 | /* ========================================================== */ 66 | /* 67 | * HACK ALERT 68 | * The intersection parameter t has the nice property that if t>1, 69 | * then the intersection is "in front of" p1, and if t<0, then the 70 | * intersection is "behind" p2. Unfortunately, as the intersecting plane 71 | * and the line become parallel, t wraps through infinity -- i.e. t can 72 | * become so large that t becomes "greater than infinity" and comes back 73 | * as a negative number (i.e. winding number hopped by one unit). We 74 | * have no way of detecting this situation without adding gazzillions 75 | * of lines of code of topological algebra to detect the winding number; 76 | * and this would be incredibly difficult, and ruin performance. 77 | * 78 | * Thus, we've installed a cheap hack for use by the "cut style" drawing 79 | * routines. If t proves to be a large negative number (more negative 80 | * than -5), then we assume that t was positive and wound through 81 | * infinity. This makes most cuts look good, without introducing bogus 82 | * cuts at infinity. 83 | */ 84 | /* ========================================================== */ 85 | 86 | #define INTERSECT(sect,p,n,v1,v2) \ 87 | { \ 88 | gleDouble deno, numer, t, omt; \ 89 | \ 90 | deno = (v1[0] - v2[0]) * n[0]; \ 91 | deno += (v1[1] - v2[1]) * n[1]; \ 92 | deno += (v1[2] - v2[2]) * n[2]; \ 93 | \ 94 | if (deno == 0.0) { \ 95 | VEC_COPY (n, v1); \ 96 | /* printf ("Intersect: Warning: line is coplanar with plane \n"); */ \ 97 | } else { \ 98 | \ 99 | numer = (p[0] - v2[0]) * n[0]; \ 100 | numer += (p[1] - v2[1]) * n[1]; \ 101 | numer += (p[2] - v2[2]) * n[2]; \ 102 | \ 103 | t = numer / deno; \ 104 | omt = 1.0 - t; \ 105 | \ 106 | sect[0] = t * v1[0] + omt * v2[0]; \ 107 | sect[1] = t * v1[1] + omt * v2[1]; \ 108 | sect[2] = t * v1[2] + omt * v2[2]; \ 109 | } \ 110 | } 111 | 112 | /* ========================================================== */ 113 | /* 114 | * The macro and subroutine BISECTING_PLANE compute a normal vector that 115 | * describes the bisecting plane between three points (v1, v2 and v3). 116 | * This bisecting plane has the following properties: 117 | * 1) it contains the point v2 118 | * 2) the angle it makes with v21 == v2 - v1 is equal to the angle it 119 | * makes with v32 == v3 - v2 120 | * 3) it is perpendicular to the plane defined by v1, v2, v3. 121 | * 122 | * Having input v1, v2, and v3, it returns a unit vector n. 123 | * 124 | * In some cases, the user may specify degenerate points, and still 125 | * expect "reasonable" or "obvious" behaviour. The "expected" 126 | * behaviour for these degenerate cases is: 127 | * 128 | * 1) if v1 == v2 == v3, then return n=0 129 | * 2) if v1 == v2, then return v32 (normalized). 130 | * 3) if v2 == v3, then return v21 (normalized). 131 | * 4) if v1, v2 and v3 co-linear, then return v21 (normalized). 132 | * 133 | * Mathematically, these special cases "make sense" -- we just have to 134 | * code around potential divide-by-zero's in the code below. 135 | */ 136 | 137 | /* ========================================================== */ 138 | 139 | #define BISECTING_PLANE(valid,n,v1,v2,v3) \ 140 | { \ 141 | double v21[3], v32[3]; \ 142 | double len21, len32; \ 143 | double vdot; \ 144 | \ 145 | VEC_DIFF (v21, v2, v1); \ 146 | VEC_DIFF (v32, v3, v2); \ 147 | \ 148 | VEC_LENGTH (len21, v21); \ 149 | VEC_LENGTH (len32, v32); \ 150 | \ 151 | if (len21 <= DEGENERATE_TOLERANCE * len32) { \ 152 | \ 153 | if (len32 == 0.0) { \ 154 | /* all three points lie ontop of one-another */ \ 155 | VEC_ZERO (n); \ 156 | valid = FALSE; \ 157 | } else { \ 158 | /* return a normalized copy of v32 as bisector */ \ 159 | len32 = 1.0 / len32; \ 160 | VEC_SCALE (n, len32, v32); \ 161 | valid = TRUE; \ 162 | } \ 163 | \ 164 | } else { \ 165 | \ 166 | valid = TRUE; \ 167 | \ 168 | if (len32 <= DEGENERATE_TOLERANCE * len21) { \ 169 | /* return a normalized copy of v21 as bisector */ \ 170 | len21 = 1.0 / len21; \ 171 | VEC_SCALE (n, len21, v21); \ 172 | \ 173 | } else { \ 174 | \ 175 | /* normalize v21 to be of unit length */ \ 176 | len21 = 1.0 / len21; \ 177 | VEC_SCALE (v21, len21, v21); \ 178 | \ 179 | /* normalize v32 to be of unit length */ \ 180 | len32 = 1.0 / len32; \ 181 | VEC_SCALE (v32, len32, v32); \ 182 | \ 183 | VEC_DOT_PRODUCT (vdot, v32, v21); \ 184 | \ 185 | /* if vdot == 1 or -1, then points are colinear */ \ 186 | if ((vdot >= (1.0-DEGENERATE_TOLERANCE)) || \ 187 | (vdot <= (-1.0+DEGENERATE_TOLERANCE))) { \ 188 | VEC_COPY (n, v21); \ 189 | } else { \ 190 | \ 191 | /* go do the full computation */ \ 192 | n[0] = vdot * (v32[0] + v21[0]) - v32[0] - v21[0]; \ 193 | n[1] = vdot * (v32[1] + v21[1]) - v32[1] - v21[1]; \ 194 | n[2] = vdot * (v32[2] + v21[2]) - v32[2] - v21[2]; \ 195 | \ 196 | /* if above if-test's passed, \ 197 | * n should NEVER be of zero length */ \ 198 | VEC_NORMALIZE (n); \ 199 | } \ 200 | } \ 201 | } \ 202 | } 203 | 204 | /* ========================================================== */ 205 | /* 206 | * The block of code below is ifdef'd out, and is here for reference 207 | * purposes only. It performs the "mathematically right thing" for 208 | * computing a bisecting plane, but is, unfortunately, subject ot noise 209 | * in the presence of near degenerate points. Since computer graphics, 210 | * due to sloppy coding, laziness, or correctness, is filled with 211 | * degenerate points, we can't really use this version. The code above 212 | * is far more appropriate for graphics. 213 | */ 214 | 215 | #ifdef MATHEMATICALLY_EXACT_GRAPHICALLY_A_KILLER 216 | #define BISECTING_PLANE(n,v1,v2,v3) \ 217 | { \ 218 | double v21[3], v32[3]; \ 219 | double len21, len32; \ 220 | double vdot; \ 221 | \ 222 | VEC_DIFF (v21, v2, v1); \ 223 | VEC_DIFF (v32, v3, v2); \ 224 | \ 225 | VEC_LENGTH (len21, v21); \ 226 | VEC_LENGTH (len32, v32); \ 227 | \ 228 | if (len21 == 0.0) { \ 229 | \ 230 | if (len32 == 0.0) { \ 231 | /* all three points lie ontop of one-another */ \ 232 | VEC_ZERO (n); \ 233 | valid = FALSE; \ 234 | } else { \ 235 | /* return a normalized copy of v32 as bisector */ \ 236 | len32 = 1.0 / len32; \ 237 | VEC_SCALE (n, len32, v32); \ 238 | } \ 239 | \ 240 | } else { \ 241 | \ 242 | /* normalize v21 to be of unit length */ \ 243 | len21 = 1.0 / len21; \ 244 | VEC_SCALE (v21, len21, v21); \ 245 | \ 246 | if (len32 == 0.0) { \ 247 | /* return a normalized copy of v21 as bisector */ \ 248 | VEC_COPY (n, v21); \ 249 | } else { \ 250 | \ 251 | /* normalize v32 to be of unit length */ \ 252 | len32 = 1.0 / len32; \ 253 | VEC_SCALE (v32, len32, v32); \ 254 | \ 255 | VEC_DOT_PRODUCT (vdot, v32, v21); \ 256 | \ 257 | /* if vdot == 1 or -1, then points are colinear */ \ 258 | if ((vdot == 1.0) || (vdot == -1.0)) { \ 259 | VEC_COPY (n, v21); \ 260 | } else { \ 261 | \ 262 | /* go do the full computation */ \ 263 | n[0] = vdot * (v32[0] + v21[0]) - v32[0] - v21[0]; \ 264 | n[1] = vdot * (v32[1] + v21[1]) - v32[1] - v21[1]; \ 265 | n[2] = vdot * (v32[2] + v21[2]) - v32[2] - v21[2]; \ 266 | \ 267 | /* if above if-test's passed, \ 268 | * n should NEVER be of zero length */ \ 269 | VEC_NORMALIZE (n); \ 270 | } \ 271 | } \ 272 | } \ 273 | } 274 | #endif 275 | 276 | /* ========================================================== */ 277 | /* 278 | * This macro computes the plane perpendicular to the the plane 279 | * defined by three points, and whose normal vector is givven as the 280 | * difference between the two vectors ... 281 | * 282 | * (See way below for the "math" model if you want to understand this. 283 | * The comments about relative errors above apply here.) 284 | */ 285 | 286 | #define CUTTING_PLANE(valid,n,v1,v2,v3) \ 287 | { \ 288 | double v21[3], v32[3]; \ 289 | double len21, len32; \ 290 | double lendiff; \ 291 | \ 292 | VEC_DIFF (v21, v2, v1); \ 293 | VEC_DIFF (v32, v3, v2); \ 294 | \ 295 | VEC_LENGTH (len21, v21); \ 296 | VEC_LENGTH (len32, v32); \ 297 | \ 298 | if (len21 <= DEGENERATE_TOLERANCE * len32) { \ 299 | \ 300 | if (len32 == 0.0) { \ 301 | /* all three points lie ontop of one-another */ \ 302 | VEC_ZERO (n); \ 303 | valid = FALSE; \ 304 | } else { \ 305 | /* return a normalized copy of v32 as cut-vector */ \ 306 | len32 = 1.0 / len32; \ 307 | VEC_SCALE (n, len32, v32); \ 308 | valid = TRUE; \ 309 | } \ 310 | \ 311 | } else { \ 312 | \ 313 | valid = TRUE; \ 314 | \ 315 | if (len32 <= DEGENERATE_TOLERANCE * len21) { \ 316 | /* return a normalized copy of v21 as cut vector */ \ 317 | len21 = 1.0 / len21; \ 318 | VEC_SCALE (n, len21, v21); \ 319 | } else { \ 320 | \ 321 | /* normalize v21 to be of unit length */ \ 322 | len21 = 1.0 / len21; \ 323 | VEC_SCALE (v21, len21, v21); \ 324 | \ 325 | /* normalize v32 to be of unit length */ \ 326 | len32 = 1.0 / len32; \ 327 | VEC_SCALE (v32, len32, v32); \ 328 | \ 329 | VEC_DIFF (n, v21, v32); \ 330 | VEC_LENGTH (lendiff, n); \ 331 | \ 332 | /* if the perp vector is very small, then the two \ 333 | * vectors are darn near collinear, and the cut \ 334 | * vector is probably poorly defined. */ \ 335 | if (lendiff < DEGENERATE_TOLERANCE) { \ 336 | VEC_ZERO (n); \ 337 | valid = FALSE; \ 338 | } else { \ 339 | lendiff = 1.0 / lendiff; \ 340 | VEC_SCALE (n, lendiff, n); \ 341 | } \ 342 | } \ 343 | } \ 344 | } 345 | 346 | /* ========================================================== */ 347 | 348 | #ifdef MATHEMATICALLY_EXACT_GRAPHICALLY_A_KILLER 349 | #define CUTTING_PLANE(n,v1,v2,v3) \ 350 | { \ 351 | double v21[3], v32[3]; \ 352 | \ 353 | VEC_DIFF (v21, v2, v1); \ 354 | VEC_DIFF (v32, v3, v2); \ 355 | \ 356 | VEC_NORMALIZE (v21); \ 357 | VEC_NORMALIZE (v32); \ 358 | \ 359 | VEC_DIFF (n, v21, v32); \ 360 | VEC_NORMALIZE (n); \ 361 | } 362 | #endif 363 | 364 | 365 | /* ============================================================ */ 366 | /* This macro is used in several places to cycle through a series of 367 | * points to find the next non-degenerate point in a series */ 368 | 369 | #define FIND_NON_DEGENERATE_POINT(inext,npoints,len,diff,point_array) \ 370 | { \ 371 | gleDouble slen; \ 372 | gleDouble summa[3]; \ 373 | \ 374 | do { \ 375 | /* get distance to next point */ \ 376 | VEC_DIFF (diff, point_array[inext+1], point_array[inext]); \ 377 | VEC_LENGTH (len, diff); \ 378 | VEC_SUM (summa, point_array[inext+1], point_array[inext]); \ 379 | VEC_LENGTH (slen, summa); \ 380 | slen *= DEGENERATE_TOLERANCE; \ 381 | inext ++; \ 382 | } while ((len <= slen) && (inext < npoints-1)); \ 383 | } 384 | 385 | /* ========================================================== */ 386 | 387 | extern int bisecting_plane (gleDouble n[3], /* returned */ 388 | gleDouble v1[3], /* input */ 389 | gleDouble v2[3], /* input */ 390 | gleDouble v3[3]); /* input */ 391 | 392 | -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Headers/port.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * port.h 4 | * 5 | * FUNCTION: 6 | * This file contains defines for porting the tubing toolkit from GL to 7 | * OpenGL to some callback scheme. 8 | * 9 | * HISTORY: 10 | * Created by Linas Vepstas -- February 1993 11 | * Added auto texture coord generation hacks, Linas April 1994 12 | */ 13 | 14 | #ifndef __GLE_PORT_H__ 15 | #define __GLE_PORT_H__ 16 | 17 | 18 | #ifndef TRUE 19 | #define TRUE 1 20 | #endif 21 | 22 | #ifndef FALSE 23 | #define FALSE 0 24 | #endif 25 | 26 | #ifndef M_PI 27 | #define M_PI 3.14159265358979323846 28 | #endif 29 | 30 | /* ====================================================== */ 31 | /* Some compilers can't handle multiply-subscripted array's */ 32 | 33 | #ifdef FUNKY_C 34 | typedef gleDouble gleVector; 35 | #define AVAL(arr,n,i,j) arr(6*n+3*i+j) 36 | #define VVAL(arr,n,i) arr(3*n+i) 37 | 38 | #else /* FUNKY_C */ 39 | typedef double gleVector[3]; 40 | typedef double glePoint[2]; 41 | #define AVAL(arr,n,i,j) arr[n][i][j] 42 | #define VVAL(arr,n,i) arr[n][i]; 43 | 44 | #endif /* FUNKY_C */ 45 | 46 | /* ====================================================== */ 47 | /* These are used to convey info about topography to the 48 | * texture mapping routines */ 49 | 50 | #define FRONT 1 51 | #define BACK 2 52 | #define FRONT_CAP 3 53 | #define BACK_CAP 4 54 | #define FILLET 5 55 | 56 | /* ====================================================== */ 57 | 58 | #define __GLE_DOUBLE 59 | 60 | /* ====================================================== */ 61 | 62 | #ifdef __GLE_DOUBLE 63 | #ifndef gleDouble 64 | #define gleDouble double 65 | #endif 66 | #define urot_axis(a,b,c) urot_axis_d(a,b,c) 67 | #define uview_direction(a,b,c) uview_direction_d(a,b,c) 68 | #define uviewpoint(a,b,c,d) uviewpoint_d(a,b,c,d) 69 | #define MULTMATRIX(m) MULTMATRIX_D(m) 70 | #define LOADMATRIX(m) LOADMATRIX_D(m) 71 | #define V3F(x,j,id) V3F_D(x,j,id) 72 | #define N3F(x) N3F_D(x) 73 | #define T2F(x,y) T2F_D(x,y) 74 | #else 75 | #define gleDouble float 76 | #define urot_axis(a,b,c) urot_axis_f(a,b,c) 77 | #define uview_direction(a,b,c) uview_direction_f(a,b,c) 78 | #define uviewpoint(a,b,c,d) uviewpoint_f(a,b,c,d) 79 | #define MULTMATRIX(m) MULTMATRIX_F(m) 80 | #define LOADMATRIX(m) LOADMATRIX_F(m) 81 | #define V3F(x,j,id) V3F_F(x,j,id) 82 | #define N3F(x) N3F_F(x) 83 | #define T2F(x,y) T2F_F(x,y) 84 | #endif 85 | 86 | /* ====================================================== */ 87 | 88 | #if (defined DEBUG_GL_32 || DEBUG_OPENGL_10) 89 | #undef GL_32 90 | #undef OPENGL_10 91 | 92 | #define BGNTMESH(i,len) printf ("bgntmesh() \n"); 93 | #define ENDTMESH() printf ("endtmesh() \n"); 94 | #define BGNPOLYGON() printf ("bgnpolygon() \n"); 95 | #define ENDPOLYGON() printf ("endpolygon() \n"); 96 | #define V3F_F(x,j,id) printf ("v3f(x) %f %f %f \n", x[0], x[1], x[2]); 97 | #define V3F_D(x,j,id) printf ("v3d(x) %f %f %f \n", x[0], x[1], x[2]); 98 | #define N3F_F(x) printf ("n3f(x) %f %f %f \n", x[0], x[1], x[2]); 99 | #define N3F_D(x) printf ("n3d(x) %f %f %f \n", x[0], x[1], x[2]); 100 | #define C3F(x) printf ("c3f(x) %f %f %f \n", x[0], x[1], x[2]); 101 | 102 | #define POPMATRIX() printf ("popmatrix () \n"); 103 | #define PUSHMATRIX() printf ("pushmatrix() \n"); 104 | #define MULTMATRIX_F(x) MULTMATRIX_D(x) 105 | #define LOADMATRIX_F(x) LOADMATRIX_D(x) 106 | 107 | 108 | #define LOADMATRIX_D(x) { \ 109 | int i, j; \ 110 | printf ("loadmatrix (x) \n"); \ 111 | for (i=0; i<4; i++) { \ 112 | for (j=0; j<4; j++) { \ 113 | printf ( "%f ", x[i][j]); \ 114 | } \ 115 | printf (" \n"); \ 116 | } \ 117 | } 118 | 119 | #define MULTMATRIX_D(x) { \ 120 | int i, j; \ 121 | printf ("multmatrix (x) \n"); \ 122 | for (i=0; i<4; i++) { \ 123 | for (j=0; j<4; j++) { \ 124 | printf ( "%f ", x[i][j]); \ 125 | } \ 126 | printf (" \n"); \ 127 | } \ 128 | } 129 | 130 | #define __IS_LIGHTING_ON (1) 131 | 132 | #endif 133 | 134 | /* ====================================================== */ 135 | 136 | #ifdef GL_32 137 | 138 | #include 139 | 140 | #define BGNTMESH(i,len) bgntmesh() 141 | #define ENDTMESH() endtmesh() 142 | #define BGNPOLYGON() bgnpolygon() 143 | #define ENDPOLYGON() endpolygon() 144 | #define V3F_F(x,j,id) v3f(x) 145 | #define V3F_D(x,j,id) v3d(x) 146 | #define N3F_F(x) n3f(x) 147 | #define T2F_F(x,y) 148 | #define T2F_D(x,y) 149 | #define C3F(x) c3f(x) 150 | 151 | #define POPMATRIX() popmatrix () 152 | #define PUSHMATRIX() pushmatrix() 153 | #define MULTMATRIX_F(x) multmatrix (x) 154 | #define LOADMATRIX_F(x) loadmatrix (x) 155 | 156 | #define N3F_D(x) { \ 157 | float nnn[3]; \ 158 | nnn[0] = (float) x[0]; \ 159 | nnn[1] = (float) x[1]; \ 160 | nnn[2] = (float) x[2]; \ 161 | n3f (nnn); \ 162 | } 163 | 164 | #define LOADMATRIX_D(x) { \ 165 | int i, j; \ 166 | float mmm[4][4]; \ 167 | for (i=0; i<4; i++) { \ 168 | for (j=0; j<4; j++) { \ 169 | mmm[i][j] = (float) x[i][j]; \ 170 | } \ 171 | } \ 172 | loadmatrix(mmm); \ 173 | } 174 | 175 | #define MULTMATRIX_D(x) { \ 176 | int i, j; \ 177 | float mmm[4][4]; \ 178 | for (i=0; i<4; i++) { \ 179 | for (j=0; j<4; j++) { \ 180 | mmm[i][j] = (float) x[i][j]; \ 181 | } \ 182 | } \ 183 | multmatrix(mmm); \ 184 | } 185 | 186 | /* #define __IS_LIGHTING_ON (MSINGLE == getmmode()) */ 187 | #define __IS_LIGHTING_ON (extrusion_join_style & TUBE_LIGHTING_ON) 188 | 189 | #endif /* GL_32 */ 190 | 191 | /* ====================================================== */ 192 | #ifdef OPENGL_10 193 | 194 | #if defined(_WIN32) 195 | #include 196 | #pragma warning (disable:4244) /* disable bogus conversion warnings */ 197 | #endif 198 | #include 199 | #include 200 | 201 | /* 202 | #define N3F_F(x) { \ 203 | float nnn[3]; \ 204 | nnn[0] = - (float) x[0]; \ 205 | nnn[1] = - (float) x[1]; \ 206 | nnn[2] = - (float) x[2]; \ 207 | glNormal3fv (nnn); \ 208 | } 209 | #define N3F_D(x) { \ 210 | float nnn[3]; \ 211 | nnn[0] = - (float) x[0]; \ 212 | nnn[1] = - (float) x[1]; \ 213 | nnn[2] = - (float) x[2]; \ 214 | glNormal3fv (nnn); \ 215 | } 216 | */ 217 | 218 | #define C3F(x) glColor3fv(x) 219 | #define T2F_F(x,y) glTexCoord2f(x,y) 220 | #define T2F_D(x,y) glTexCoord2d(x,y) 221 | 222 | #define POPMATRIX() glPopMatrix() 223 | #define PUSHMATRIX() glPushMatrix() 224 | 225 | #define MULTMATRIX_F(x) glMultMatrixf ((const GLfloat *)x) 226 | #define LOADMATRIX_F(x) glLoadMatrixf ((const GLfloat *)x) 227 | 228 | #define MULTMATRIX_D(x) glMultMatrixd ((const GLdouble *)x) 229 | #define LOADMATRIX_D(x) glLoadMatrixd ((const GLdouble *)x) 230 | 231 | #define __IS_LIGHTING_ON (glIsEnabled(GL_LIGHTING)) 232 | 233 | /* ====================================================== */ 234 | #ifdef AUTO_TEXTURE 235 | 236 | #define BGNTMESH(i,len) { \ 237 | if(_gle_gc -> bgn_gen_texture) (*(_gle_gc -> bgn_gen_texture))(i,len);\ 238 | glBegin (GL_TRIANGLE_STRIP); \ 239 | } 240 | 241 | #define BGNPOLYGON() { \ 242 | if(_gle_gc -> bgn_gen_texture) (*(_gle_gc -> bgn_gen_texture))();\ 243 | glBegin (GL_POLYGON); \ 244 | } 245 | 246 | #define N3F_F(x) { \ 247 | if(_gle_gc -> n3f_gen_texture) (*(_gle_gc -> n3f_gen_texture))(x); \ 248 | glNormal3fv(x); \ 249 | } 250 | 251 | #define N3F_D(x) { \ 252 | if(_gle_gc -> n3d_gen_texture) (*(_gle_gc -> n3d_gen_texture))(x); \ 253 | glNormal3dv(x); \ 254 | } 255 | 256 | #define V3F_F(x,j,id) { \ 257 | if(_gle_gc -> v3f_gen_texture) (*(_gle_gc -> v3f_gen_texture))(x,j,id);\ 258 | glVertex3fv(x); \ 259 | } 260 | 261 | #define V3F_D(x,j,id) { \ 262 | if(_gle_gc -> v3d_gen_texture) (*(_gle_gc -> v3d_gen_texture))(x,j,id); \ 263 | glVertex3dv(x); \ 264 | } 265 | 266 | #define ENDTMESH() { \ 267 | if(_gle_gc -> end_gen_texture) (*(_gle_gc -> end_gen_texture))(); \ 268 | glEnd (); \ 269 | } 270 | 271 | #define ENDPOLYGON() { \ 272 | if(_gle_gc -> end_gen_texture) (*(_gle_gc -> end_gen_texture))(); \ 273 | glEnd (); \ 274 | } 275 | 276 | /* ====================================================== */ 277 | #else /* AUTO_TEXTURE */ 278 | 279 | #define BGNTMESH(i,len) glBegin (GL_TRIANGLE_STRIP); 280 | #define BGNPOLYGON() glBegin (GL_POLYGON); 281 | 282 | #define N3F_F(x) glNormal3fv(x) 283 | #define N3F_D(x) glNormal3dv(x) 284 | #define V3F_F(x,j,id) glVertex3fv(x); 285 | #define V3F_D(x,j,id) glVertex3dv(x); 286 | 287 | #define ENDTMESH() glEnd () 288 | #define ENDPOLYGON() glEnd() 289 | 290 | #endif /* AUTO_TEXTURE */ 291 | 292 | #endif /* OPENGL_10 */ 293 | 294 | /* ====================================================== */ 295 | 296 | 297 | #endif /* __GLE_PORT_H__ */ 298 | /* ================== END OF FILE ======================= */ 299 | -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Headers/rot.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * rot.h 4 | * 5 | * FUNCTION: 6 | * rotation matrix utilities 7 | * 8 | * HISTORY: 9 | * Linas Vepstas Aug 1990 10 | */ 11 | 12 | /* ========================================================== */ 13 | /* 14 | * The MACROS below generate and return more traditional rotation 15 | * matrices -- matrices for rotations about principal axes. 16 | */ 17 | /* ========================================================== */ 18 | 19 | #define ROTX_CS(m,cosine,sine) \ 20 | { \ 21 | /* rotation about the x-axis */ \ 22 | \ 23 | m[0][0] = 1.0; \ 24 | m[0][1] = 0.0; \ 25 | m[0][2] = 0.0; \ 26 | m[0][3] = 0.0; \ 27 | \ 28 | m[1][0] = 0.0; \ 29 | m[1][1] = (cosine); \ 30 | m[1][2] = (sine); \ 31 | m[1][3] = 0.0; \ 32 | \ 33 | m[2][0] = 0.0; \ 34 | m[2][1] = -(sine); \ 35 | m[2][2] = (cosine); \ 36 | m[2][3] = 0.0; \ 37 | \ 38 | m[3][0] = 0.0; \ 39 | m[3][1] = 0.0; \ 40 | m[3][2] = 0.0; \ 41 | m[3][3] = 1.0; \ 42 | } 43 | 44 | /* ========================================================== */ 45 | 46 | #define ROTY_CS(m,cosine,sine) \ 47 | { \ 48 | /* rotation about the y-axis */ \ 49 | \ 50 | m[0][0] = (cosine); \ 51 | m[0][1] = 0.0; \ 52 | m[0][2] = -(sine); \ 53 | m[0][3] = 0.0; \ 54 | \ 55 | m[1][0] = 0.0; \ 56 | m[1][1] = 1.0; \ 57 | m[1][2] = 0.0; \ 58 | m[1][3] = 0.0; \ 59 | \ 60 | m[2][0] = (sine); \ 61 | m[2][1] = 0.0; \ 62 | m[2][2] = (cosine); \ 63 | m[2][3] = 0.0; \ 64 | \ 65 | m[3][0] = 0.0; \ 66 | m[3][1] = 0.0; \ 67 | m[3][2] = 0.0; \ 68 | m[3][3] = 1.0; \ 69 | } 70 | 71 | /* ========================================================== */ 72 | 73 | #define ROTZ_CS(m,cosine,sine) \ 74 | { \ 75 | /* rotation about the z-axis */ \ 76 | \ 77 | m[0][0] = (cosine); \ 78 | m[0][1] = (sine); \ 79 | m[0][2] = 0.0; \ 80 | m[0][3] = 0.0; \ 81 | \ 82 | m[1][0] = -(sine); \ 83 | m[1][1] = (cosine); \ 84 | m[1][2] = 0.0; \ 85 | m[1][3] = 0.0; \ 86 | \ 87 | m[2][0] = 0.0; \ 88 | m[2][1] = 0.0; \ 89 | m[2][2] = 1.0; \ 90 | m[2][3] = 0.0; \ 91 | \ 92 | m[3][0] = 0.0; \ 93 | m[3][1] = 0.0; \ 94 | m[3][2] = 0.0; \ 95 | m[3][3] = 1.0; \ 96 | } 97 | 98 | /* ========================================================== */ 99 | -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Headers/segment.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * MODULE: segment.h 4 | * 5 | * FUNCTION: 6 | * Contains function prototypes for segment drawing subroutines. 7 | * These are used only internally, and are not to be exported to 8 | * the user. 9 | * 10 | * HISTORY: 11 | * Create by Linas Vepstas 12 | * Added tube.h include to define gleDouble, tad February 2002 13 | */ 14 | 15 | /* ============================================================ */ 16 | 17 | #include "tube.h" 18 | 19 | extern void draw_segment_plain (int ncp, /* number of contour points */ 20 | gleDouble front_contour[][3], 21 | gleDouble back_contour[][3], 22 | int inext, double len); 23 | 24 | extern void draw_segment_color (int ncp, /* number of contour points */ 25 | gleDouble front_contour[][3], 26 | gleDouble back_contour[][3], 27 | float color_last[3], 28 | float color_next[3], 29 | int inext, double len); 30 | 31 | extern void draw_segment_edge_n (int ncp, /* number of contour points */ 32 | gleDouble front_contour[][3], 33 | gleDouble back_contour[][3], 34 | double norm_cont[][3], 35 | int inext, double len); 36 | 37 | extern void draw_segment_c_and_edge_n (int ncp, 38 | gleDouble front_contour[][3], 39 | gleDouble back_contour[][3], 40 | double norm_cont[][3], 41 | float color_last[3], 42 | float color_next[3], 43 | int inext, double len); 44 | 45 | extern void draw_segment_facet_n (int ncp, 46 | gleDouble front_contour[][3], 47 | gleDouble back_contour[][3], 48 | double norm_cont[][3], 49 | int inext, double len); 50 | 51 | extern void draw_segment_c_and_facet_n (int ncp, 52 | gleDouble front_contour[][3], 53 | gleDouble back_contour[][3], 54 | double norm_cont[][3], 55 | float color_last[3], 56 | float color_next[3], 57 | int inext, double len); 58 | 59 | /* ============================================================ */ 60 | 61 | extern void draw_binorm_segment_edge_n (int ncp, 62 | double front_contour[][3], 63 | double back_contour[][3], 64 | double front_norm[][3], 65 | double back_norm[][3], 66 | int inext, double len); 67 | 68 | extern void draw_binorm_segment_c_and_edge_n (int ncp, 69 | double front_contour[][3], 70 | double back_contour[][3], 71 | double front_norm[][3], 72 | double back_norm[][3], 73 | float color_last[3], 74 | float color_next[3], 75 | int inext, double len); 76 | 77 | extern void draw_binorm_segment_facet_n (int ncp, 78 | double front_contour[][3], 79 | double back_contour[][3], 80 | double front_norm[][3], 81 | double back_norm[][3], 82 | int inext, double len); 83 | 84 | extern void draw_binorm_segment_c_and_facet_n (int ncp, 85 | double front_contour[][3], 86 | double back_contour[][3], 87 | double front_norm[][3], 88 | double back_norm[][3], 89 | float color_last[3], 90 | float color_next[3], 91 | int inext, double len); 92 | 93 | extern void draw_angle_style_back_cap (int ncp, /* number of contour points */ 94 | gleDouble bi[3], /* biscetor */ 95 | gleDouble point_array[][3]); /* polyline */ 96 | 97 | /* -------------------------- end of file -------------------------------- */ 98 | 99 | -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Headers/tube.h: -------------------------------------------------------------------------------- 1 | /* 2 | * tube.h 3 | * 4 | * FUNCTION: 5 | * Tubing and Extrusion header file. 6 | * This file provides protypes and defines for the extrusion 7 | * and tubing primitives. 8 | * 9 | * HISTORY: 10 | * Linas Vepstas 1990, 1991 11 | */ 12 | 13 | #ifndef __TUBE_H__ 14 | #define __TUBE_H__ 15 | 16 | #ifdef __cplusplus 17 | extern "C" { 18 | #endif 19 | 20 | /** 21 | GLE API revision history: 22 | 23 | GLE_API_VERSION is updated to reflect GLE API changes (interface 24 | changes, semantic changes, deletions, or additions). 25 | 26 | GLE_API_VERSION=228 GLUT 3.7 release of GLE. 27 | **/ 28 | #ifndef GLE_API_VERSION /* allow this to be overriden */ 29 | #define GLE_API_VERSION 228 30 | #endif 31 | 32 | /* some types */ 33 | #ifndef gleDouble 34 | #define gleDouble double 35 | #endif 36 | typedef gleDouble gleAffine[2][3]; 37 | 38 | /* ====================================================== */ 39 | 40 | /* defines for tubing join styles */ 41 | #define TUBE_JN_RAW 0x1 42 | #define TUBE_JN_ANGLE 0x2 43 | #define TUBE_JN_CUT 0x3 44 | #define TUBE_JN_ROUND 0x4 45 | #define TUBE_JN_MASK 0xf /* mask bits */ 46 | #define TUBE_JN_CAP 0x10 47 | 48 | /* determine how normal vectors are to be handled */ 49 | #define TUBE_NORM_FACET 0x100 50 | #define TUBE_NORM_EDGE 0x200 51 | #define TUBE_NORM_PATH_EDGE 0x400 /* for spiral, lathe, helix primitives */ 52 | #define TUBE_NORM_MASK 0xf00 /* mask bits */ 53 | 54 | /* closed or open countours */ 55 | #define TUBE_CONTOUR_CLOSED 0x1000 56 | 57 | #define GLE_TEXTURE_ENABLE 0x10000 58 | #define GLE_TEXTURE_STYLE_MASK 0xff 59 | #define GLE_TEXTURE_VERTEX_FLAT 1 60 | #define GLE_TEXTURE_NORMAL_FLAT 2 61 | #define GLE_TEXTURE_VERTEX_CYL 3 62 | #define GLE_TEXTURE_NORMAL_CYL 4 63 | #define GLE_TEXTURE_VERTEX_SPH 5 64 | #define GLE_TEXTURE_NORMAL_SPH 6 65 | #define GLE_TEXTURE_VERTEX_MODEL_FLAT 7 66 | #define GLE_TEXTURE_NORMAL_MODEL_FLAT 8 67 | #define GLE_TEXTURE_VERTEX_MODEL_CYL 9 68 | #define GLE_TEXTURE_NORMAL_MODEL_CYL 10 69 | #define GLE_TEXTURE_VERTEX_MODEL_SPH 11 70 | #define GLE_TEXTURE_NORMAL_MODEL_SPH 12 71 | 72 | #ifdef GL_32 73 | /* HACK for GL 3.2 -- needed because no way to tell if lighting is on. */ 74 | #define TUBE_LIGHTING_ON 0x80000000 75 | 76 | #define gleExtrusion extrusion 77 | #define gleSetJoinStyle setjoinstyle 78 | #define gleGetJoinStyle getjoinstyle 79 | #define glePolyCone polycone 80 | #define glePolyCylinder polycylinder 81 | #define gleSuperExtrusion super_extrusion 82 | #define gleTwistExtrusion twist_extrusion 83 | #define gleSpiral spiral 84 | #define gleLathe lathe 85 | #define gleHelicoid helicoid 86 | #define gleToroid toroid 87 | #define gleScrew screw 88 | 89 | #endif /* GL_32 */ 90 | 91 | extern int gleGetJoinStyle (void); 92 | extern void gleSetJoinStyle (int style); /* bitwise OR of flags */ 93 | extern int gleGetNumSlices(void); 94 | extern void gleSetNumSlices(int slices); 95 | 96 | /* draw polyclinder, specified as a polyline */ 97 | extern void glePolyCylinder (int npoints, /* num points in polyline */ 98 | gleDouble point_array[][3], /* polyline vertces */ 99 | float color_array[][3], /* colors at polyline verts */ 100 | gleDouble radius); /* radius of polycylinder */ 101 | 102 | /* draw polycone, specified as a polyline with radii */ 103 | extern void glePolyCone (int npoints, /* numpoints in poly-line */ 104 | gleDouble point_array[][3], /* polyline vertices */ 105 | float color_array[][3], /* colors at polyline verts */ 106 | gleDouble radius_array[]); /* cone radii at polyline verts */ 107 | 108 | /* extrude arbitrary 2D contour along arbitrary 3D path */ 109 | extern void gleExtrusion (int ncp, /* number of contour points */ 110 | gleDouble contour[][2], /* 2D contour */ 111 | gleDouble cont_normal[][2], /* 2D contour normals */ 112 | gleDouble up[3], /* up vector for contour */ 113 | int npoints, /* numpoints in poly-line */ 114 | gleDouble point_array[][3], /* polyline vertices */ 115 | float color_array[][3]); /* colors at polyline verts */ 116 | 117 | /* extrude 2D contour, specifying local rotations (twists) */ 118 | extern void gleTwistExtrusion (int ncp, /* number of contour points */ 119 | gleDouble contour[][2], /* 2D contour */ 120 | gleDouble cont_normal[][2], /* 2D contour normals */ 121 | gleDouble up[3], /* up vector for contour */ 122 | int npoints, /* numpoints in poly-line */ 123 | gleDouble point_array[][3], /* polyline vertices */ 124 | float color_array[][3], /* color at polyline verts */ 125 | gleDouble twist_array[]); /* countour twists (in degrees) */ 126 | 127 | /* extrude 2D contour, specifying local affine tranformations */ 128 | extern void gleSuperExtrusion (int ncp, /* number of contour points */ 129 | gleDouble contour[][2], /* 2D contour */ 130 | gleDouble cont_normal[][2], /* 2D contour normals */ 131 | gleDouble up[3], /* up vector for contour */ 132 | int npoints, /* numpoints in poly-line */ 133 | gleDouble point_array[][3], /* polyline vertices */ 134 | float color_array[][3], /* color at polyline verts */ 135 | gleDouble xform_array[][2][3]); /* 2D contour xforms */ 136 | 137 | /* spiral moves contour along helical path by parallel transport */ 138 | extern void gleSpiral (int ncp, /* number of contour points */ 139 | gleDouble contour[][2], /* 2D contour */ 140 | gleDouble cont_normal[][2], /* 2D contour normals */ 141 | gleDouble up[3], /* up vector for contour */ 142 | gleDouble startRadius, /* spiral starts in x-y plane */ 143 | gleDouble drdTheta, /* change in radius per revolution */ 144 | gleDouble startZ, /* starting z value */ 145 | gleDouble dzdTheta, /* change in Z per revolution */ 146 | gleDouble startXform[2][3], /* starting contour affine xform */ 147 | gleDouble dXformdTheta[2][3], /* tangent change xform per revoln */ 148 | gleDouble startTheta, /* start angle in x-y plane */ 149 | gleDouble sweepTheta); /* degrees to spiral around */ 150 | 151 | /* lathe moves contour along helical path by helically shearing 3D space */ 152 | extern void gleLathe (int ncp, /* number of contour points */ 153 | gleDouble contour[][2], /* 2D contour */ 154 | gleDouble cont_normal[][2], /* 2D contour normals */ 155 | gleDouble up[3], /* up vector for contour */ 156 | gleDouble startRadius, /* spiral starts in x-y plane */ 157 | gleDouble drdTheta, /* change in radius per revolution */ 158 | gleDouble startZ, /* starting z value */ 159 | gleDouble dzdTheta, /* change in Z per revolution */ 160 | gleDouble startXform[2][3], /* starting contour affine xform */ 161 | gleDouble dXformdTheta[2][3], /* tangent change xform per revoln */ 162 | gleDouble startTheta, /* start angle in x-y plane */ 163 | gleDouble sweepTheta); /* degrees to spiral around */ 164 | 165 | /* similar to spiral, except contour is a circle */ 166 | extern void gleHelicoid (gleDouble rToroid, /* circle contour (torus) radius */ 167 | gleDouble startRadius, /* spiral starts in x-y plane */ 168 | gleDouble drdTheta, /* change in radius per revolution */ 169 | gleDouble startZ, /* starting z value */ 170 | gleDouble dzdTheta, /* change in Z per revolution */ 171 | gleDouble startXform[2][3], /* starting contour affine xform */ 172 | gleDouble dXformdTheta[2][3], /* tangent change xform per revoln */ 173 | gleDouble startTheta, /* start angle in x-y plane */ 174 | gleDouble sweepTheta); /* degrees to spiral around */ 175 | 176 | /* similar to lathe, except contour is a circle */ 177 | extern void gleToroid (gleDouble rToroid, /* circle contour (torus) radius */ 178 | gleDouble startRadius, /* spiral starts in x-y plane */ 179 | gleDouble drdTheta, /* change in radius per revolution */ 180 | gleDouble startZ, /* starting z value */ 181 | gleDouble dzdTheta, /* change in Z per revolution */ 182 | gleDouble startXform[2][3], /* starting contour affine xform */ 183 | gleDouble dXformdTheta[2][3], /* tangent change xform per revoln */ 184 | gleDouble startTheta, /* start angle in x-y plane */ 185 | gleDouble sweepTheta); /* degrees to spiral around */ 186 | 187 | /* draws a screw shape */ 188 | extern void gleScrew (int ncp, /* number of contour points */ 189 | gleDouble contour[][2], /* 2D contour */ 190 | gleDouble cont_normal[][2], /* 2D contour normals */ 191 | gleDouble up[3], /* up vector for contour */ 192 | gleDouble startz, /* start of segment */ 193 | gleDouble endz, /* end of segment */ 194 | gleDouble twist); /* number of rotations */ 195 | 196 | extern void gleTextureMode (int mode); 197 | 198 | #ifdef __cplusplus 199 | } 200 | 201 | #endif 202 | #endif /* __TUBE_H__ */ 203 | /* ================== END OF FILE ======================= */ 204 | -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Headers/tube_gc.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * tube_gc.h 4 | * 5 | * FUNCTION: 6 | * This file allows for easy changes to changes in the way the extrusion 7 | * library handles state info (i.e. context). 8 | * 9 | * HISTORY: 10 | * Linas Vepstas --- February 1993 11 | * Added auto texture coord generation hacks, Linas April 1994 12 | * Added tube.h include to define gleDouble, tad February 2002 13 | */ 14 | 15 | #include "tube.h" 16 | #include "port.h" /* for gleVector */ 17 | 18 | typedef float gleColor[3]; 19 | typedef double gleTwoVec[2]; 20 | 21 | typedef struct { 22 | 23 | /* public methods */ 24 | void (*bgn_gen_texture) (int, double); 25 | void (*n3f_gen_texture) (float *); 26 | void (*n3d_gen_texture) (double *); 27 | void (*v3f_gen_texture) (float *, int, int); 28 | void (*v3d_gen_texture) (double *, int, int); 29 | void (*end_gen_texture) (void); 30 | 31 | /* protected members -- "general knowledge" stuff */ 32 | int join_style; 33 | 34 | /* arguments passed into extrusion code */ 35 | int ncp; /* number of contour points */ 36 | gleTwoVec *contour; /* 2D contour */ 37 | gleTwoVec *cont_normal; /* 2D contour normals */ 38 | gleDouble *up; /* up vector */ 39 | int npoints; /* number of points in polyline */ 40 | gleVector *point_array; /* path */ 41 | gleColor *color_array; /* path colors */ 42 | gleAffine *xform_array; /* contour xforms */ 43 | 44 | /* private members, used by texturing code */ 45 | int num_vert; 46 | int segment_number; 47 | double segment_length; 48 | double accum_seg_len; 49 | double prev_x; 50 | double prev_y; 51 | 52 | void (*save_bgn_gen_texture) (int, double); 53 | void (*save_n3f_gen_texture) (float *); 54 | void (*save_n3d_gen_texture) (double *); 55 | void (*save_v3f_gen_texture) (float *, int, int); 56 | void (*save_v3d_gen_texture) (double *, int, int); 57 | void (*save_end_gen_texture) (void); 58 | 59 | } gleGC; 60 | 61 | extern gleGC *_gle_gc; 62 | extern gleGC * gleCreateGC (void); 63 | 64 | #define INIT_GC() {if (!_gle_gc) _gle_gc = gleCreateGC(); } 65 | #define extrusion_join_style (_gle_gc->join_style) 66 | 67 | #define __TUBE_CLOSE_CONTOUR (extrusion_join_style & TUBE_CONTOUR_CLOSED) 68 | #define __TUBE_DRAW_CAP (extrusion_join_style & TUBE_JN_CAP) 69 | #define __TUBE_DRAW_FACET_NORMALS (extrusion_join_style & TUBE_NORM_FACET) 70 | #define __TUBE_DRAW_PATH_EDGE_NORMALS (extrusion_join_style & TUBE_NORM_PATH_EDGE) 71 | 72 | #define __TUBE_STYLE (extrusion_join_style & TUBE_JN_MASK) 73 | #define __TUBE_RAW_JOIN (extrusion_join_style & TUBE_JN_RAW) 74 | #define __TUBE_CUT_JOIN (extrusion_join_style & TUBE_JN_CUT) 75 | #define __TUBE_ANGLE_JOIN (extrusion_join_style & TUBE_JN_ANGLE) 76 | #define __TUBE_ROUND_JOIN (extrusion_join_style & TUBE_JN_ROUND) 77 | 78 | /* ======================= END OF FILE ========================== */ 79 | -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/Caution.tiff: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/laserpilot/shaderSandbox/32c692f28779ba0c5f30aefb3958ec38e3f21f4e/bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/Caution.tiff -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/English.lproj/GLUT.nib/classes.nib: -------------------------------------------------------------------------------- 1 | { 2 | IBClasses = ( 3 | { 4 | ACTIONS = {save = id; saveAs = id; }; 5 | CLASS = FirstResponder; 6 | LANGUAGE = ObjC; 7 | SUPERCLASS = NSObject; 8 | }, 9 | { 10 | ACTIONS = {timerAction = id; }; 11 | CLASS = GLUTApplication; 12 | LANGUAGE = ObjC; 13 | OUTLETS = { 14 | "_aboutMenuItem" = NSMenuItem; 15 | "_hideMenuItem" = NSMenuItem; 16 | "_quitMenuItem" = NSMenuItem; 17 | }; 18 | SUPERCLASS = NSApplication; 19 | }, 20 | { 21 | ACTIONS = {toggleWindow = id; }; 22 | CLASS = GLUTClipboardController; 23 | LANGUAGE = ObjC; 24 | OUTLETS = {"_infoText" = id; "_scrollView" = id; }; 25 | SUPERCLASS = NSWindowController; 26 | }, 27 | { 28 | ACTIONS = { 29 | assign = id; 30 | cancel = id; 31 | inputMenu = id; 32 | invertInput = id; 33 | mouseMatrix = id; 34 | mousePreset = id; 35 | ok = id; 36 | setDefault = id; 37 | }; 38 | CLASS = GLUTPreferencesController; 39 | LANGUAGE = ObjC; 40 | OUTLETS = { 41 | assignPrompt = NSTextField; 42 | assignText = NSTextField; 43 | inputMenu = NSPopUpButton; 44 | inverted = NSButton; 45 | mbConfigMenu = NSPopUpButton; 46 | mbConfigWarningIcon = NSImageView; 47 | mbConfigWarningText = NSTextField; 48 | middleButtonMatrix = NSMatrix; 49 | rightButtonMatrix = NSMatrix; 50 | }; 51 | SUPERCLASS = NSWindowController; 52 | } 53 | ); 54 | IBVersion = 1; 55 | } -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/English.lproj/GLUT.nib/info.nib: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | IBDocumentLocation 6 | 4 104 410 240 0 0 1152 848 7 | IBEditorPositions 8 | 9 | 29 10 | 19 615 246 44 0 0 1152 848 11 | 12 | IBFramework Version 13 | 291.0 14 | IBGroupedObjects 15 | 16 | IBLastGroupID 17 | 1 18 | IBOpenObjects 19 | 20 | 29 21 | 22 | IBSystem Version 23 | 6I32 24 | 25 | 26 | -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/English.lproj/GLUT.nib/objects.nib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/laserpilot/shaderSandbox/32c692f28779ba0c5f30aefb3958ec38e3f21f4e/bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/English.lproj/GLUT.nib/objects.nib -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/English.lproj/GLUTClipboard.nib/classes.nib: -------------------------------------------------------------------------------- 1 | { 2 | IBClasses = ( 3 | {CLASS = FirstResponder; LANGUAGE = ObjC; SUPERCLASS = NSObject; }, 4 | { 5 | ACTIONS = {toggleWindow = id; }; 6 | CLASS = GLUTClipboardController; 7 | LANGUAGE = ObjC; 8 | OUTLETS = {_infoText = id; _scrollView = id; }; 9 | SUPERCLASS = NSWindowController; 10 | } 11 | ); 12 | IBVersion = 1; 13 | } -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/English.lproj/GLUTClipboard.nib/info.nib: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | IBDocumentLocation 6 | 63 221 356 240 0 0 1600 1178 7 | IBFramework Version 8 | 263.2 9 | IBSystem Version 10 | 5S41 11 | 12 | 13 | -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/English.lproj/GLUTClipboard.nib/objects.nib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/laserpilot/shaderSandbox/32c692f28779ba0c5f30aefb3958ec38e3f21f4e/bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/English.lproj/GLUTClipboard.nib/objects.nib -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/English.lproj/GLUTPreferences.nib/classes.nib: -------------------------------------------------------------------------------- 1 | { 2 | IBClasses = ( 3 | { 4 | ACTIONS = {save = id; saveAs = id; }; 5 | CLASS = FirstResponder; 6 | LANGUAGE = ObjC; 7 | SUPERCLASS = NSObject; 8 | }, 9 | { 10 | ACTIONS = { 11 | cancel = id; 12 | joyAssign = id; 13 | joyDevice = id; 14 | joyElement = id; 15 | joyInvert = id; 16 | launchDebugMode = id; 17 | launchGamemodeCaptureSingle = id; 18 | launchIconic = id; 19 | launchUseCurrWD = id; 20 | launchUseExtDesktop = id; 21 | launchUseMacOSCoords = id; 22 | mouseEanbleEmulation = id; 23 | mouseMiddleMenu = id; 24 | mouseRightMenu = id; 25 | ok = id; 26 | spaceAssign = id; 27 | spaceDevice = id; 28 | spaceElement = id; 29 | spaceInvert = id; 30 | }; 31 | CLASS = GLUTPreferencesController; 32 | LANGUAGE = ObjC; 33 | OUTLETS = { 34 | joyAssign = NSButton; 35 | joyAssignNote = NSTextField; 36 | joyAssignWarningIcon = NSImageView; 37 | joyDeviceMenu = NSPopUpButton; 38 | joyElement = NSTextField; 39 | joyInputMenu = NSPopUpButton; 40 | joyInverted = NSButton; 41 | launchDebugMode = NSButton; 42 | launchFadeTime = NSTextField; 43 | launchGamemodeCaptureSingle = NSButton; 44 | launchIconic = NSButton; 45 | launchInitHeight = NSTextField; 46 | launchInitWidth = NSTextField; 47 | launchInitX = NSTextField; 48 | launchInitY = NSTextField; 49 | launchMenuIdle = NSTextField; 50 | launchSyncToVBL = NSButton; 51 | launchUseCurrWD = NSButton; 52 | launchUseExtendedDesktop = NSButton; 53 | launchUseMacOSXCoords = NSButton; 54 | mouseAssignWarningIcon = NSImageView; 55 | mouseAssignWarningText = NSTextField; 56 | mouseDetected = NSTextField; 57 | mouseEmulation = NSButton; 58 | mouseMiddleConfigMenu = NSPopUpButton; 59 | mouseRightConfigMenu = NSPopUpButton; 60 | prefsTabView = NSTabView; 61 | spaceAssign = NSButton; 62 | spaceAssignNote = NSTextField; 63 | spaceAssignWarningIcon = NSImageView; 64 | spaceDeviceMenu = NSPopUpButton; 65 | spaceElement = NSTextField; 66 | spaceInputMenu = NSPopUpButton; 67 | spaceInverted = NSButton; 68 | }; 69 | SUPERCLASS = NSWindowController; 70 | } 71 | ); 72 | IBVersion = 1; 73 | } -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/English.lproj/GLUTPreferences.nib/info.nib: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | IBDocumentLocation 6 | 16 329 410 240 0 0 1920 1178 7 | IBFramework Version 8 | 439.0 9 | IBOpenObjects 10 | 11 | 205 12 | 13 | IBSystem Version 14 | 8G32 15 | 16 | 17 | -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/English.lproj/GLUTPreferences.nib/objects.nib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/laserpilot/shaderSandbox/32c692f28779ba0c5f30aefb3958ec38e3f21f4e/bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/English.lproj/GLUTPreferences.nib/objects.nib -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/English.lproj/GLUTUI.strings: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/laserpilot/shaderSandbox/32c692f28779ba0c5f30aefb3958ec38e3f21f4e/bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/English.lproj/GLUTUI.strings -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/English.lproj/InfoPlist.strings: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/laserpilot/shaderSandbox/32c692f28779ba0c5f30aefb3958ec38e3f21f4e/bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/English.lproj/InfoPlist.strings -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/Info.plist: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | CFBundleDevelopmentRegion 6 | English 7 | CFBundleExecutable 8 | GLUT 9 | CFBundleGetInfoString 10 | 3.4.0, Copyright (c) 2001-2008 Apple Inc., All Rights Reserved 11 | CFBundleIdentifier 12 | com.apple.glut 13 | CFBundleInfoDictionaryVersion 14 | 6.0 15 | CFBundlePackageType 16 | FMWK 17 | CFBundleShortVersionString 18 | 3.4.0 19 | CFBundleSignature 20 | ???? 21 | CFBundleVersion 22 | GLUT-3.4.0 23 | 24 | 25 | -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/blankCursor.tiff: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/laserpilot/shaderSandbox/32c692f28779ba0c5f30aefb3958ec38e3f21f4e/bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/blankCursor.tiff -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/bottomCursor.tiff: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/laserpilot/shaderSandbox/32c692f28779ba0c5f30aefb3958ec38e3f21f4e/bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/bottomCursor.tiff -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/bottomleftCursor.tiff: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/laserpilot/shaderSandbox/32c692f28779ba0c5f30aefb3958ec38e3f21f4e/bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/bottomleftCursor.tiff -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/bottomrightCursor.tiff: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/laserpilot/shaderSandbox/32c692f28779ba0c5f30aefb3958ec38e3f21f4e/bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/bottomrightCursor.tiff -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/crossCursor.tiff: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/laserpilot/shaderSandbox/32c692f28779ba0c5f30aefb3958ec38e3f21f4e/bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/crossCursor.tiff -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/cycleCursor.tiff: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/laserpilot/shaderSandbox/32c692f28779ba0c5f30aefb3958ec38e3f21f4e/bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/cycleCursor.tiff -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/destroyCursor.tiff: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/laserpilot/shaderSandbox/32c692f28779ba0c5f30aefb3958ec38e3f21f4e/bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/destroyCursor.tiff -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/fingerCursor.tiff: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/laserpilot/shaderSandbox/32c692f28779ba0c5f30aefb3958ec38e3f21f4e/bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/fingerCursor.tiff -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/helpCursor.tiff: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/laserpilot/shaderSandbox/32c692f28779ba0c5f30aefb3958ec38e3f21f4e/bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/helpCursor.tiff -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/leftCursor.tiff: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/laserpilot/shaderSandbox/32c692f28779ba0c5f30aefb3958ec38e3f21f4e/bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/leftCursor.tiff -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/leftRightCursor.tiff: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/laserpilot/shaderSandbox/32c692f28779ba0c5f30aefb3958ec38e3f21f4e/bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/leftRightCursor.tiff -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/rightArrowCursor.tiff: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/laserpilot/shaderSandbox/32c692f28779ba0c5f30aefb3958ec38e3f21f4e/bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/rightArrowCursor.tiff -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/rightCursor.tiff: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/laserpilot/shaderSandbox/32c692f28779ba0c5f30aefb3958ec38e3f21f4e/bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/rightCursor.tiff -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/sprayCursor.tiff: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/laserpilot/shaderSandbox/32c692f28779ba0c5f30aefb3958ec38e3f21f4e/bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/sprayCursor.tiff -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/topCursor.tiff: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/laserpilot/shaderSandbox/32c692f28779ba0c5f30aefb3958ec38e3f21f4e/bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/topCursor.tiff -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/topleftCursor.tiff: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/laserpilot/shaderSandbox/32c692f28779ba0c5f30aefb3958ec38e3f21f4e/bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/topleftCursor.tiff -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/toprightCursor.tiff: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/laserpilot/shaderSandbox/32c692f28779ba0c5f30aefb3958ec38e3f21f4e/bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/toprightCursor.tiff -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/upDownCursor.tiff: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/laserpilot/shaderSandbox/32c692f28779ba0c5f30aefb3958ec38e3f21f4e/bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/upDownCursor.tiff -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/waitCursor.tiff: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/laserpilot/shaderSandbox/32c692f28779ba0c5f30aefb3958ec38e3f21f4e/bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/A/Resources/waitCursor.tiff -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Frameworks/GLUT.framework/Versions/Current: -------------------------------------------------------------------------------- 1 | A -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/Info.plist: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | BuildMachineOSBuild 6 | 11E53 7 | CFBundleDevelopmentRegion 8 | English 9 | CFBundleExecutable 10 | emptyExampleDebug 11 | CFBundleIdentifier 12 | com.yourcompany.openFrameworks 13 | CFBundleInfoDictionaryVersion 14 | 6.0 15 | CFBundlePackageType 16 | APPL 17 | CFBundleSignature 18 | ???? 19 | CFBundleVersion 20 | 1.0 21 | DTCompiler 22 | 23 | DTPlatformBuild 24 | 4G108j 25 | DTPlatformVersion 26 | GM 27 | DTSDKBuild 28 | 11E52 29 | DTSDKName 30 | macosx10.7 31 | DTXcode 32 | 0450 33 | DTXcodeBuild 34 | 4G108j 35 | 36 | 37 | -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/MacOS/emptyExampleDebug: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/laserpilot/shaderSandbox/32c692f28779ba0c5f30aefb3958ec38e3f21f4e/bin/emptyExampleDebug.app/Contents/MacOS/emptyExampleDebug -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/MacOS/libfmodex.dylib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/laserpilot/shaderSandbox/32c692f28779ba0c5f30aefb3958ec38e3f21f4e/bin/emptyExampleDebug.app/Contents/MacOS/libfmodex.dylib -------------------------------------------------------------------------------- /bin/emptyExampleDebug.app/Contents/PkgInfo: -------------------------------------------------------------------------------- 1 | APPL???? -------------------------------------------------------------------------------- /config.make: -------------------------------------------------------------------------------- 1 | ################################################################################ 2 | # CONFIGURE PROJECT MAKEFILE (optional) 3 | # This file is where we make project specific configurations. 4 | ################################################################################ 5 | 6 | ################################################################################ 7 | # OF ROOT 8 | # The location of your root openFrameworks installation 9 | # (default) OF_ROOT = ../../.. 10 | ################################################################################ 11 | # OF_ROOT = ../../.. 12 | 13 | ################################################################################ 14 | # PROJECT ROOT 15 | # The location of the project - a starting place for searching for files 16 | # (default) PROJECT_ROOT = . (this directory) 17 | # 18 | ################################################################################ 19 | # PROJECT_ROOT = . 20 | 21 | ################################################################################ 22 | # PROJECT SPECIFIC CHECKS 23 | # This is a project defined section to create internal makefile flags to 24 | # conditionally enable or disable the addition of various features within 25 | # this makefile. For instance, if you want to make changes based on whether 26 | # GTK is installed, one might test that here and create a variable to check. 27 | ################################################################################ 28 | # None 29 | 30 | ################################################################################ 31 | # PROJECT EXTERNAL SOURCE PATHS 32 | # These are fully qualified paths that are not within the PROJECT_ROOT folder. 33 | # Like source folders in the PROJECT_ROOT, these paths are subject to 34 | # exlclusion via the PROJECT_EXLCUSIONS list. 35 | # 36 | # (default) PROJECT_EXTERNAL_SOURCE_PATHS = (blank) 37 | # 38 | # Note: Leave a leading space when adding list items with the += operator 39 | ################################################################################ 40 | # PROJECT_EXTERNAL_SOURCE_PATHS = 41 | 42 | ################################################################################ 43 | # PROJECT EXCLUSIONS 44 | # These makefiles assume that all folders in your current project directory 45 | # and any listed in the PROJECT_EXTERNAL_SOURCH_PATHS are are valid locations 46 | # to look for source code. The any folders or files that match any of the 47 | # items in the PROJECT_EXCLUSIONS list below will be ignored. 48 | # 49 | # Each item in the PROJECT_EXCLUSIONS list will be treated as a complete 50 | # string unless teh user adds a wildcard (%) operator to match subdirectories. 51 | # GNU make only allows one wildcard for matching. The second wildcard (%) is 52 | # treated literally. 53 | # 54 | # (default) PROJECT_EXCLUSIONS = (blank) 55 | # 56 | # Will automatically exclude the following: 57 | # 58 | # $(PROJECT_ROOT)/bin% 59 | # $(PROJECT_ROOT)/obj% 60 | # $(PROJECT_ROOT)/%.xcodeproj 61 | # 62 | # Note: Leave a leading space when adding list items with the += operator 63 | ################################################################################ 64 | # PROJECT_EXCLUSIONS = 65 | 66 | ################################################################################ 67 | # PROJECT LINKER FLAGS 68 | # These flags will be sent to the linker when compiling the executable. 69 | # 70 | # (default) PROJECT_LDFLAGS = -Wl,-rpath=./libs 71 | # 72 | # Note: Leave a leading space when adding list items with the += operator 73 | ################################################################################ 74 | 75 | # Currently, shared libraries that are needed are copied to the 76 | # $(PROJECT_ROOT)/bin/libs directory. The following LDFLAGS tell the linker to 77 | # add a runtime path to search for those shared libraries, since they aren't 78 | # incorporated directly into the final executable application binary. 79 | # TODO: should this be a default setting? 80 | # PROJECT_LDFLAGS=-Wl,-rpath=./libs 81 | 82 | ################################################################################ 83 | # PROJECT DEFINES 84 | # Create a space-delimited list of DEFINES. The list will be converted into 85 | # CFLAGS with the "-D" flag later in the makefile. 86 | # 87 | # (default) PROJECT_DEFINES = (blank) 88 | # 89 | # Note: Leave a leading space when adding list items with the += operator 90 | ################################################################################ 91 | # PROJECT_DEFINES = 92 | 93 | ################################################################################ 94 | # PROJECT CFLAGS 95 | # This is a list of fully qualified CFLAGS required when compiling for this 96 | # project. These CFLAGS will be used IN ADDITION TO the PLATFORM_CFLAGS 97 | # defined in your platform specific core configuration files. These flags are 98 | # presented to the compiler BEFORE the PROJECT_OPTIMIZATION_CFLAGS below. 99 | # 100 | # (default) PROJECT_CFLAGS = (blank) 101 | # 102 | # Note: Before adding PROJECT_CFLAGS, note that the PLATFORM_CFLAGS defined in 103 | # your platform specific configuration file will be applied by default and 104 | # further flags here may not be needed. 105 | # 106 | # Note: Leave a leading space when adding list items with the += operator 107 | ################################################################################ 108 | # PROJECT_CFLAGS = 109 | 110 | ################################################################################ 111 | # PROJECT OPTIMIZATION CFLAGS 112 | # These are lists of CFLAGS that are target-specific. While any flags could 113 | # be conditionally added, they are usually limited to optimization flags. 114 | # These flags are added BEFORE the PROJECT_CFLAGS. 115 | # 116 | # PROJECT_OPTIMIZATION_CFLAGS_RELEASE flags are only applied to RELEASE targets. 117 | # 118 | # (default) PROJECT_OPTIMIZATION_CFLAGS_RELEASE = (blank) 119 | # 120 | # PROJECT_OPTIMIZATION_CFLAGS_DEBUG flags are only applied to DEBUG targets. 121 | # 122 | # (default) PROJECT_OPTIMIZATION_CFLAGS_DEBUG = (blank) 123 | # 124 | # Note: Before adding PROJECT_OPTIMIZATION_CFLAGS, please note that the 125 | # PLATFORM_OPTIMIZATION_CFLAGS defined in your platform specific configuration 126 | # file will be applied by default and further optimization flags here may not 127 | # be needed. 128 | # 129 | # Note: Leave a leading space when adding list items with the += operator 130 | ################################################################################ 131 | # PROJECT_OPTIMIZATION_CFLAGS_RELEASE = 132 | # PROJECT_OPTIMIZATION_CFLAGS_DEBUG = 133 | 134 | ################################################################################ 135 | # PROJECT COMPILERS 136 | # Custom compilers can be set for CC and CXX 137 | # (default) PROJECT_CXX = (blank) 138 | # (default) PROJECT_CC = (blank) 139 | # Note: Leave a leading space when adding list items with the += operator 140 | ################################################################################ 141 | # PROJECT_CXX = 142 | # PROJECT_CC = 143 | -------------------------------------------------------------------------------- /openFrameworks-Info.plist: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | CFBundleDevelopmentRegion 6 | English 7 | CFBundleExecutable 8 | ${EXECUTABLE_NAME} 9 | CFBundleIdentifier 10 | cc.openFrameworks.ofapp 11 | CFBundleInfoDictionaryVersion 12 | 6.0 13 | CFBundlePackageType 14 | APPL 15 | CFBundleSignature 16 | ???? 17 | CFBundleVersion 18 | 1.0 19 | CFBundleIconFile 20 | ${ICON} 21 | 22 | 23 | -------------------------------------------------------------------------------- /screengrab.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/laserpilot/shaderSandbox/32c692f28779ba0c5f30aefb3958ec38e3f21f4e/screengrab.png -------------------------------------------------------------------------------- /shaderSandbox.xcodeproj/project.pbxproj: -------------------------------------------------------------------------------- 1 | // !$*UTF8*$! 2 | { 3 | archiveVersion = 1; 4 | classes = { 5 | }; 6 | objectVersion = 46; 7 | objects = { 8 | 9 | /* Begin PBXBuildFile section */ 10 | E4328149138ABC9F0047C5CB /* openFrameworksDebug.a in Frameworks */ = {isa = PBXBuildFile; fileRef = E4328148138ABC890047C5CB /* openFrameworksDebug.a */; }; 11 | E4B69E200A3A1BDC003C02F2 /* main.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E4B69E1D0A3A1BDC003C02F2 /* main.cpp */; }; 12 | E4B69E210A3A1BDC003C02F2 /* ofApp.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E4B69E1E0A3A1BDC003C02F2 /* ofApp.cpp */; }; 13 | /* End PBXBuildFile section */ 14 | 15 | /* Begin PBXContainerItemProxy section */ 16 | E4328147138ABC890047C5CB /* PBXContainerItemProxy */ = { 17 | isa = PBXContainerItemProxy; 18 | containerPortal = E4328143138ABC890047C5CB /* openFrameworksLib.xcodeproj */; 19 | proxyType = 2; 20 | remoteGlobalIDString = E4B27C1510CBEB8E00536013; 21 | remoteInfo = openFrameworks; 22 | }; 23 | E4EEB9AB138B136A00A80321 /* PBXContainerItemProxy */ = { 24 | isa = PBXContainerItemProxy; 25 | containerPortal = E4328143138ABC890047C5CB /* openFrameworksLib.xcodeproj */; 26 | proxyType = 1; 27 | remoteGlobalIDString = E4B27C1410CBEB8E00536013; 28 | remoteInfo = openFrameworks; 29 | }; 30 | /* End PBXContainerItemProxy section */ 31 | 32 | /* Begin PBXCopyFilesBuildPhase section */ 33 | E4C2427710CC5ABF004149E2 /* CopyFiles */ = { 34 | isa = PBXCopyFilesBuildPhase; 35 | buildActionMask = 2147483647; 36 | dstPath = ""; 37 | dstSubfolderSpec = 10; 38 | files = ( 39 | ); 40 | runOnlyForDeploymentPostprocessing = 0; 41 | }; 42 | /* End PBXCopyFilesBuildPhase section */ 43 | 44 | /* Begin PBXFileReference section */ 45 | 503C2BD21BF552F7002A5847 /* 3Dlabs-license.txt */ = {isa = PBXFileReference; lastKnownFileType = text; path = "3Dlabs-license.txt"; sourceTree = ""; }; 46 | 503C2BD31BF552F7002A5847 /* bloom_GLSL.frag */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.glsl; path = bloom_GLSL.frag; sourceTree = ""; }; 47 | 503C2BD41BF552F7002A5847 /* bloom_GLSL.vert */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.glsl; path = bloom_GLSL.vert; sourceTree = ""; }; 48 | 503C2BD51BF552F7002A5847 /* brcosa_GLSL.frag */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.glsl; path = brcosa_GLSL.frag; sourceTree = ""; }; 49 | 503C2BD61BF552F7002A5847 /* brcosa_GLSL.vert */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.glsl; path = brcosa_GLSL.vert; sourceTree = ""; }; 50 | 503C2BD71BF552F7002A5847 /* CarToPol_GLSL.frag */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.glsl; path = CarToPol_GLSL.frag; sourceTree = ""; }; 51 | 503C2BD81BF552F7002A5847 /* CarToPol_GLSL.vert */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.glsl; path = CarToPol_GLSL.vert; sourceTree = ""; }; 52 | 503C2BD91BF552F7002A5847 /* ChromaAb_GLSL.frag */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.glsl; path = ChromaAb_GLSL.frag; sourceTree = ""; }; 53 | 503C2BDA1BF552F7002A5847 /* ChromaAb_GLSL.vert */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.glsl; path = ChromaAb_GLSL.vert; sourceTree = ""; }; 54 | 503C2BDB1BF552F7002A5847 /* Fisheye_GLSL.frag */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.glsl; path = Fisheye_GLSL.frag; sourceTree = ""; }; 55 | 503C2BDC1BF552F7002A5847 /* Fisheye_GLSL.vert */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.glsl; path = Fisheye_GLSL.vert; sourceTree = ""; }; 56 | 503C2BDD1BF552F7002A5847 /* Gauss_GLSL.frag */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.glsl; path = Gauss_GLSL.frag; sourceTree = ""; }; 57 | 503C2BDE1BF552F7002A5847 /* Gauss_GLSL.vert */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.glsl; path = Gauss_GLSL.vert; sourceTree = ""; }; 58 | 503C2BDF1BF552F7002A5847 /* LumaKey_GLSL.frag */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.glsl; path = LumaKey_GLSL.frag; sourceTree = ""; }; 59 | 503C2BE01BF552F7002A5847 /* LumaKey_GLSL.vert */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.glsl; path = LumaKey_GLSL.vert; sourceTree = ""; }; 60 | 503C2BE11BF552F7002A5847 /* Rota_GLSL.frag */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.glsl; path = Rota_GLSL.frag; sourceTree = ""; }; 61 | 503C2BE21BF552F7002A5847 /* Rota_GLSL.vert */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.glsl; path = Rota_GLSL.vert; sourceTree = ""; }; 62 | 503C2BE31BF552F7002A5847 /* vertexChomAbPassthrough.glsl */ = {isa = PBXFileReference; lastKnownFileType = text; path = vertexChomAbPassthrough.glsl; sourceTree = ""; }; 63 | 503C2BE41BF552F7002A5847 /* Wobble_GLSL.frag */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.glsl; path = Wobble_GLSL.frag; sourceTree = ""; }; 64 | 503C2BE51BF552F7002A5847 /* Wobble_GLSL.vert */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.glsl; path = Wobble_GLSL.vert; sourceTree = ""; }; 65 | E4328143138ABC890047C5CB /* openFrameworksLib.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = openFrameworksLib.xcodeproj; path = ../../../libs/openFrameworksCompiled/project/osx/openFrameworksLib.xcodeproj; sourceTree = SOURCE_ROOT; }; 66 | E4B69B5B0A3A1756003C02F2 /* shaderSandboxDebug.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = shaderSandboxDebug.app; sourceTree = BUILT_PRODUCTS_DIR; }; 67 | E4B69E1D0A3A1BDC003C02F2 /* main.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = main.cpp; path = src/main.cpp; sourceTree = SOURCE_ROOT; }; 68 | E4B69E1E0A3A1BDC003C02F2 /* ofApp.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 30; name = ofApp.cpp; path = src/ofApp.cpp; sourceTree = SOURCE_ROOT; }; 69 | E4B69E1F0A3A1BDC003C02F2 /* ofApp.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = ofApp.h; path = src/ofApp.h; sourceTree = SOURCE_ROOT; }; 70 | E4B6FCAD0C3E899E008CF71C /* openFrameworks-Info.plist */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = text.plist.xml; path = "openFrameworks-Info.plist"; sourceTree = ""; }; 71 | E4EB691F138AFCF100A09F29 /* CoreOF.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; name = CoreOF.xcconfig; path = ../../../libs/openFrameworksCompiled/project/osx/CoreOF.xcconfig; sourceTree = SOURCE_ROOT; }; 72 | E4EB6923138AFD0F00A09F29 /* Project.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = Project.xcconfig; sourceTree = ""; }; 73 | /* End PBXFileReference section */ 74 | 75 | /* Begin PBXFrameworksBuildPhase section */ 76 | E4B69B590A3A1756003C02F2 /* Frameworks */ = { 77 | isa = PBXFrameworksBuildPhase; 78 | buildActionMask = 2147483647; 79 | files = ( 80 | E4328149138ABC9F0047C5CB /* openFrameworksDebug.a in Frameworks */, 81 | ); 82 | runOnlyForDeploymentPostprocessing = 0; 83 | }; 84 | /* End PBXFrameworksBuildPhase section */ 85 | 86 | /* Begin PBXGroup section */ 87 | 503C2BD11BF552F7002A5847 /* shaders */ = { 88 | isa = PBXGroup; 89 | children = ( 90 | 503C2BD21BF552F7002A5847 /* 3Dlabs-license.txt */, 91 | 503C2BD31BF552F7002A5847 /* bloom_GLSL.frag */, 92 | 503C2BD41BF552F7002A5847 /* bloom_GLSL.vert */, 93 | 503C2BD51BF552F7002A5847 /* brcosa_GLSL.frag */, 94 | 503C2BD61BF552F7002A5847 /* brcosa_GLSL.vert */, 95 | 503C2BD71BF552F7002A5847 /* CarToPol_GLSL.frag */, 96 | 503C2BD81BF552F7002A5847 /* CarToPol_GLSL.vert */, 97 | 503C2BD91BF552F7002A5847 /* ChromaAb_GLSL.frag */, 98 | 503C2BDA1BF552F7002A5847 /* ChromaAb_GLSL.vert */, 99 | 503C2BDB1BF552F7002A5847 /* Fisheye_GLSL.frag */, 100 | 503C2BDC1BF552F7002A5847 /* Fisheye_GLSL.vert */, 101 | 503C2BDD1BF552F7002A5847 /* Gauss_GLSL.frag */, 102 | 503C2BDE1BF552F7002A5847 /* Gauss_GLSL.vert */, 103 | 503C2BDF1BF552F7002A5847 /* LumaKey_GLSL.frag */, 104 | 503C2BE01BF552F7002A5847 /* LumaKey_GLSL.vert */, 105 | 503C2BE11BF552F7002A5847 /* Rota_GLSL.frag */, 106 | 503C2BE21BF552F7002A5847 /* Rota_GLSL.vert */, 107 | 503C2BE31BF552F7002A5847 /* vertexChomAbPassthrough.glsl */, 108 | 503C2BE41BF552F7002A5847 /* Wobble_GLSL.frag */, 109 | 503C2BE51BF552F7002A5847 /* Wobble_GLSL.vert */, 110 | ); 111 | name = shaders; 112 | path = bin/data/shaders; 113 | sourceTree = ""; 114 | }; 115 | 6948EE371B920CB800B5AC1A /* local_addons */ = { 116 | isa = PBXGroup; 117 | children = ( 118 | ); 119 | name = local_addons; 120 | sourceTree = ""; 121 | }; 122 | BB4B014C10F69532006C3DED /* addons */ = { 123 | isa = PBXGroup; 124 | children = ( 125 | ); 126 | name = addons; 127 | sourceTree = ""; 128 | }; 129 | E4328144138ABC890047C5CB /* Products */ = { 130 | isa = PBXGroup; 131 | children = ( 132 | E4328148138ABC890047C5CB /* openFrameworksDebug.a */, 133 | ); 134 | name = Products; 135 | sourceTree = ""; 136 | }; 137 | E4B69B4A0A3A1720003C02F2 = { 138 | isa = PBXGroup; 139 | children = ( 140 | E4B6FCAD0C3E899E008CF71C /* openFrameworks-Info.plist */, 141 | E4EB6923138AFD0F00A09F29 /* Project.xcconfig */, 142 | 503C2BD11BF552F7002A5847 /* shaders */, 143 | E4B69E1C0A3A1BDC003C02F2 /* src */, 144 | E4EEC9E9138DF44700A80321 /* openFrameworks */, 145 | BB4B014C10F69532006C3DED /* addons */, 146 | 6948EE371B920CB800B5AC1A /* local_addons */, 147 | E4B69B5B0A3A1756003C02F2 /* shaderSandboxDebug.app */, 148 | ); 149 | sourceTree = ""; 150 | }; 151 | E4B69E1C0A3A1BDC003C02F2 /* src */ = { 152 | isa = PBXGroup; 153 | children = ( 154 | E4B69E1D0A3A1BDC003C02F2 /* main.cpp */, 155 | E4B69E1E0A3A1BDC003C02F2 /* ofApp.cpp */, 156 | E4B69E1F0A3A1BDC003C02F2 /* ofApp.h */, 157 | ); 158 | path = src; 159 | sourceTree = SOURCE_ROOT; 160 | }; 161 | E4EEC9E9138DF44700A80321 /* openFrameworks */ = { 162 | isa = PBXGroup; 163 | children = ( 164 | E4EB691F138AFCF100A09F29 /* CoreOF.xcconfig */, 165 | E4328143138ABC890047C5CB /* openFrameworksLib.xcodeproj */, 166 | ); 167 | name = openFrameworks; 168 | sourceTree = ""; 169 | }; 170 | /* End PBXGroup section */ 171 | 172 | /* Begin PBXNativeTarget section */ 173 | E4B69B5A0A3A1756003C02F2 /* shaderSandbox */ = { 174 | isa = PBXNativeTarget; 175 | buildConfigurationList = E4B69B5F0A3A1757003C02F2 /* Build configuration list for PBXNativeTarget "shaderSandbox" */; 176 | buildPhases = ( 177 | E4B69B580A3A1756003C02F2 /* Sources */, 178 | E4B69B590A3A1756003C02F2 /* Frameworks */, 179 | E4B6FFFD0C3F9AB9008CF71C /* ShellScript */, 180 | E4C2427710CC5ABF004149E2 /* CopyFiles */, 181 | ); 182 | buildRules = ( 183 | ); 184 | dependencies = ( 185 | E4EEB9AC138B136A00A80321 /* PBXTargetDependency */, 186 | ); 187 | name = shaderSandbox; 188 | productName = myOFApp; 189 | productReference = E4B69B5B0A3A1756003C02F2 /* shaderSandboxDebug.app */; 190 | productType = "com.apple.product-type.application"; 191 | }; 192 | /* End PBXNativeTarget section */ 193 | 194 | /* Begin PBXProject section */ 195 | E4B69B4C0A3A1720003C02F2 /* Project object */ = { 196 | isa = PBXProject; 197 | attributes = { 198 | LastUpgradeCheck = 0600; 199 | }; 200 | buildConfigurationList = E4B69B4D0A3A1720003C02F2 /* Build configuration list for PBXProject "shaderSandbox" */; 201 | compatibilityVersion = "Xcode 3.2"; 202 | developmentRegion = English; 203 | hasScannedForEncodings = 0; 204 | knownRegions = ( 205 | English, 206 | Japanese, 207 | French, 208 | German, 209 | ); 210 | mainGroup = E4B69B4A0A3A1720003C02F2; 211 | productRefGroup = E4B69B4A0A3A1720003C02F2; 212 | projectDirPath = ""; 213 | projectReferences = ( 214 | { 215 | ProductGroup = E4328144138ABC890047C5CB /* Products */; 216 | ProjectRef = E4328143138ABC890047C5CB /* openFrameworksLib.xcodeproj */; 217 | }, 218 | ); 219 | projectRoot = ""; 220 | targets = ( 221 | E4B69B5A0A3A1756003C02F2 /* shaderSandbox */, 222 | ); 223 | }; 224 | /* End PBXProject section */ 225 | 226 | /* Begin PBXReferenceProxy section */ 227 | E4328148138ABC890047C5CB /* openFrameworksDebug.a */ = { 228 | isa = PBXReferenceProxy; 229 | fileType = archive.ar; 230 | path = openFrameworksDebug.a; 231 | remoteRef = E4328147138ABC890047C5CB /* PBXContainerItemProxy */; 232 | sourceTree = BUILT_PRODUCTS_DIR; 233 | }; 234 | /* End PBXReferenceProxy section */ 235 | 236 | /* Begin PBXShellScriptBuildPhase section */ 237 | E4B6FFFD0C3F9AB9008CF71C /* ShellScript */ = { 238 | isa = PBXShellScriptBuildPhase; 239 | buildActionMask = 2147483647; 240 | files = ( 241 | ); 242 | inputPaths = ( 243 | ); 244 | outputPaths = ( 245 | ); 246 | runOnlyForDeploymentPostprocessing = 0; 247 | shellPath = /bin/sh; 248 | shellScript = "rsync -aved ../../../libs/fmodex/lib/osx/libfmodex.dylib \"$TARGET_BUILD_DIR/$PRODUCT_NAME.app/Contents/MacOS/\"; install_name_tool -change ./libfmodex.dylib @executable_path/libfmodex.dylib \"$TARGET_BUILD_DIR/$PRODUCT_NAME.app/Contents/MacOS/$PRODUCT_NAME\";\nmkdir -p \"$TARGET_BUILD_DIR/$PRODUCT_NAME.app/Contents/Resources/\"\nrsync -aved \"$ICON_FILE\" \"$TARGET_BUILD_DIR/$PRODUCT_NAME.app/Contents/Resources/\"\nrsync -aved ../../../libs/glut/lib/osx/GLUT.framework \"$TARGET_BUILD_DIR/$PRODUCT_NAME.app/Contents/Frameworks/\"\n"; 249 | }; 250 | /* End PBXShellScriptBuildPhase section */ 251 | 252 | /* Begin PBXSourcesBuildPhase section */ 253 | E4B69B580A3A1756003C02F2 /* Sources */ = { 254 | isa = PBXSourcesBuildPhase; 255 | buildActionMask = 2147483647; 256 | files = ( 257 | E4B69E200A3A1BDC003C02F2 /* main.cpp in Sources */, 258 | E4B69E210A3A1BDC003C02F2 /* ofApp.cpp in Sources */, 259 | ); 260 | runOnlyForDeploymentPostprocessing = 0; 261 | }; 262 | /* End PBXSourcesBuildPhase section */ 263 | 264 | /* Begin PBXTargetDependency section */ 265 | E4EEB9AC138B136A00A80321 /* PBXTargetDependency */ = { 266 | isa = PBXTargetDependency; 267 | name = openFrameworks; 268 | targetProxy = E4EEB9AB138B136A00A80321 /* PBXContainerItemProxy */; 269 | }; 270 | /* End PBXTargetDependency section */ 271 | 272 | /* Begin XCBuildConfiguration section */ 273 | E4B69B4E0A3A1720003C02F2 /* Debug */ = { 274 | isa = XCBuildConfiguration; 275 | baseConfigurationReference = E4EB6923138AFD0F00A09F29 /* Project.xcconfig */; 276 | buildSettings = { 277 | CONFIGURATION_BUILD_DIR = "$(SRCROOT)/bin/"; 278 | COPY_PHASE_STRIP = NO; 279 | DEAD_CODE_STRIPPING = YES; 280 | GCC_AUTO_VECTORIZATION = YES; 281 | GCC_ENABLE_SSE3_EXTENSIONS = YES; 282 | GCC_ENABLE_SUPPLEMENTAL_SSE3_INSTRUCTIONS = YES; 283 | GCC_INLINES_ARE_PRIVATE_EXTERN = NO; 284 | GCC_OPTIMIZATION_LEVEL = 0; 285 | GCC_SYMBOLS_PRIVATE_EXTERN = NO; 286 | GCC_WARN_ABOUT_DEPRECATED_FUNCTIONS = YES; 287 | GCC_WARN_ABOUT_INVALID_OFFSETOF_MACRO = NO; 288 | GCC_WARN_ALLOW_INCOMPLETE_PROTOCOL = NO; 289 | GCC_WARN_UNINITIALIZED_AUTOS = NO; 290 | GCC_WARN_UNUSED_VALUE = NO; 291 | GCC_WARN_UNUSED_VARIABLE = NO; 292 | HEADER_SEARCH_PATHS = ( 293 | "$(OF_CORE_HEADERS)", 294 | src, 295 | ); 296 | MACOSX_DEPLOYMENT_TARGET = 10.8; 297 | ONLY_ACTIVE_ARCH = YES; 298 | OTHER_CPLUSPLUSFLAGS = ( 299 | "-D__MACOSX_CORE__", 300 | "-mtune=native", 301 | ); 302 | SDKROOT = macosx; 303 | }; 304 | name = Debug; 305 | }; 306 | E4B69B4F0A3A1720003C02F2 /* Release */ = { 307 | isa = XCBuildConfiguration; 308 | baseConfigurationReference = E4EB6923138AFD0F00A09F29 /* Project.xcconfig */; 309 | buildSettings = { 310 | CONFIGURATION_BUILD_DIR = "$(SRCROOT)/bin/"; 311 | COPY_PHASE_STRIP = YES; 312 | DEAD_CODE_STRIPPING = YES; 313 | GCC_AUTO_VECTORIZATION = YES; 314 | GCC_ENABLE_SSE3_EXTENSIONS = YES; 315 | GCC_ENABLE_SUPPLEMENTAL_SSE3_INSTRUCTIONS = YES; 316 | GCC_INLINES_ARE_PRIVATE_EXTERN = NO; 317 | GCC_OPTIMIZATION_LEVEL = 3; 318 | GCC_SYMBOLS_PRIVATE_EXTERN = NO; 319 | GCC_UNROLL_LOOPS = YES; 320 | GCC_WARN_ABOUT_DEPRECATED_FUNCTIONS = YES; 321 | GCC_WARN_ABOUT_INVALID_OFFSETOF_MACRO = NO; 322 | GCC_WARN_ALLOW_INCOMPLETE_PROTOCOL = NO; 323 | GCC_WARN_UNINITIALIZED_AUTOS = NO; 324 | GCC_WARN_UNUSED_VALUE = NO; 325 | GCC_WARN_UNUSED_VARIABLE = NO; 326 | HEADER_SEARCH_PATHS = ( 327 | "$(OF_CORE_HEADERS)", 328 | src, 329 | ); 330 | MACOSX_DEPLOYMENT_TARGET = 10.8; 331 | OTHER_CPLUSPLUSFLAGS = ( 332 | "-D__MACOSX_CORE__", 333 | "-mtune=native", 334 | ); 335 | SDKROOT = macosx; 336 | }; 337 | name = Release; 338 | }; 339 | E4B69B600A3A1757003C02F2 /* Debug */ = { 340 | isa = XCBuildConfiguration; 341 | baseConfigurationReference = E4EB6923138AFD0F00A09F29 /* Project.xcconfig */; 342 | buildSettings = { 343 | COMBINE_HIDPI_IMAGES = YES; 344 | COPY_PHASE_STRIP = NO; 345 | FRAMEWORK_SEARCH_PATHS = ( 346 | "$(inherited)", 347 | "$(FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_1)", 348 | ); 349 | FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_1 = "\"$(SRCROOT)/../../../libs/glut/lib/osx\""; 350 | GCC_DYNAMIC_NO_PIC = NO; 351 | GCC_GENERATE_DEBUGGING_SYMBOLS = YES; 352 | GCC_MODEL_TUNING = NONE; 353 | HEADER_SEARCH_PATHS = ( 354 | "$(OF_CORE_HEADERS)", 355 | src, 356 | ); 357 | ICON = "$(ICON_NAME_DEBUG)"; 358 | ICON_FILE = "$(ICON_FILE_PATH)$(ICON)"; 359 | INFOPLIST_FILE = "openFrameworks-Info.plist"; 360 | INSTALL_PATH = "$(HOME)/Applications"; 361 | LIBRARY_SEARCH_PATHS = "$(inherited)"; 362 | PRODUCT_NAME = "$(TARGET_NAME)Debug"; 363 | WRAPPER_EXTENSION = app; 364 | }; 365 | name = Debug; 366 | }; 367 | E4B69B610A3A1757003C02F2 /* Release */ = { 368 | isa = XCBuildConfiguration; 369 | baseConfigurationReference = E4EB6923138AFD0F00A09F29 /* Project.xcconfig */; 370 | buildSettings = { 371 | COMBINE_HIDPI_IMAGES = YES; 372 | COPY_PHASE_STRIP = YES; 373 | FRAMEWORK_SEARCH_PATHS = ( 374 | "$(inherited)", 375 | "$(FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_1)", 376 | ); 377 | FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_1 = "\"$(SRCROOT)/../../../libs/glut/lib/osx\""; 378 | GCC_GENERATE_DEBUGGING_SYMBOLS = YES; 379 | GCC_MODEL_TUNING = NONE; 380 | HEADER_SEARCH_PATHS = ( 381 | "$(OF_CORE_HEADERS)", 382 | src, 383 | ); 384 | ICON = "$(ICON_NAME_RELEASE)"; 385 | ICON_FILE = "$(ICON_FILE_PATH)$(ICON)"; 386 | INFOPLIST_FILE = "openFrameworks-Info.plist"; 387 | INSTALL_PATH = "$(HOME)/Applications"; 388 | LIBRARY_SEARCH_PATHS = "$(inherited)"; 389 | PRODUCT_NAME = "$(TARGET_NAME)"; 390 | WRAPPER_EXTENSION = app; 391 | baseConfigurationReference = E4EB6923138AFD0F00A09F29; 392 | }; 393 | name = Release; 394 | }; 395 | /* End XCBuildConfiguration section */ 396 | 397 | /* Begin XCConfigurationList section */ 398 | E4B69B4D0A3A1720003C02F2 /* Build configuration list for PBXProject "shaderSandbox" */ = { 399 | isa = XCConfigurationList; 400 | buildConfigurations = ( 401 | E4B69B4E0A3A1720003C02F2 /* Debug */, 402 | E4B69B4F0A3A1720003C02F2 /* Release */, 403 | ); 404 | defaultConfigurationIsVisible = 0; 405 | defaultConfigurationName = Release; 406 | }; 407 | E4B69B5F0A3A1757003C02F2 /* Build configuration list for PBXNativeTarget "shaderSandbox" */ = { 408 | isa = XCConfigurationList; 409 | buildConfigurations = ( 410 | E4B69B600A3A1757003C02F2 /* Debug */, 411 | E4B69B610A3A1757003C02F2 /* Release */, 412 | ); 413 | defaultConfigurationIsVisible = 0; 414 | defaultConfigurationName = Release; 415 | }; 416 | /* End XCConfigurationList section */ 417 | }; 418 | rootObject = E4B69B4C0A3A1720003C02F2 /* Project object */; 419 | } 420 | -------------------------------------------------------------------------------- /shaderSandbox.xcodeproj/project.xcworkspace/contents.xcworkspacedata: -------------------------------------------------------------------------------- 1 | 2 | 4 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /shaderSandbox.xcodeproj/project.xcworkspace/xcuserdata/laser.xcuserdatad/UserInterfaceState.xcuserstate: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/laserpilot/shaderSandbox/32c692f28779ba0c5f30aefb3958ec38e3f21f4e/shaderSandbox.xcodeproj/project.xcworkspace/xcuserdata/laser.xcuserdatad/UserInterfaceState.xcuserstate -------------------------------------------------------------------------------- /shaderSandbox.xcodeproj/xcshareddata/xcschemes/shaderSandbox Debug.xcscheme: -------------------------------------------------------------------------------- 1 | 2 | 5 | 8 | 9 | 15 | 21 | 22 | 23 | 24 | 25 | 30 | 31 | 32 | 33 | 39 | 40 | 41 | 42 | 51 | 52 | 58 | 59 | 60 | 61 | 62 | 63 | 69 | 70 | 76 | 77 | 78 | 79 | 81 | 82 | 85 | 86 | 87 | -------------------------------------------------------------------------------- /shaderSandbox.xcodeproj/xcshareddata/xcschemes/shaderSandbox Release.xcscheme: -------------------------------------------------------------------------------- 1 | 2 | 5 | 8 | 9 | 15 | 21 | 22 | 23 | 24 | 25 | 30 | 31 | 32 | 33 | 39 | 40 | 41 | 42 | 51 | 52 | 58 | 59 | 60 | 61 | 62 | 63 | 69 | 70 | 76 | 77 | 78 | 79 | 81 | 82 | 85 | 86 | 87 | -------------------------------------------------------------------------------- /shaderSandbox.xcodeproj/xcuserdata/laser.xcuserdatad/xcschemes/xcschememanagement.plist: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | SuppressBuildableAutocreation 6 | 7 | E4B69B5A0A3A1756003C02F2 8 | 9 | primary 10 | 11 | 12 | 13 | 14 | 15 | -------------------------------------------------------------------------------- /src/main.cpp: -------------------------------------------------------------------------------- 1 | #include "ofApp.h" 2 | #include "ofAppGlutWindow.h" 3 | 4 | //-------------------------------------------------------------- 5 | int main(){ 6 | //ofAppGlutWindow window; // create a window 7 | // set width, height, mode (OF_WINDOW or OF_FULLSCREEN) 8 | //ofSetupOpenGL(&window, 1280, 720, OF_WINDOW); 9 | ofSetupOpenGL(1280, 720, OF_WINDOW); 10 | ofRunApp(new ofApp()); // start the app 11 | } 12 | -------------------------------------------------------------------------------- /src/ofApp.cpp: -------------------------------------------------------------------------------- 1 | #include "ofApp.h" 2 | 3 | //-------------------------------------------------------------- 4 | void ofApp::setup(){ 5 | 6 | //CHECK ALL SHADER PERMISSIONS BEFORE RELEASING 7 | 8 | camWidth=640; 9 | camHeight = 480; 10 | 11 | vidGrabber.initGrabber(camWidth, camHeight); 12 | 13 | tex1.setTextureWrap(GL_REPEAT, GL_REPEAT); 14 | tex1.allocate(400,400,GL_RGB,GL_RGBA); 15 | 16 | brcosaFbo.allocate(320, 240, GL_RGBA); 17 | brcosaFbo.begin(); 18 | ofClear(0, 0, 0,0); //Clear the FBO 19 | brcosaFbo.end(); 20 | 21 | chromaFbo.allocate(320, 240, GL_RGBA); 22 | chromaFbo.begin(); 23 | ofClear(0, 0, 0,0); //Clear the FBO 24 | chromaFbo.end(); 25 | 26 | cout<<"Load BLOOM"<