#BASICS # doc snippet doc /** * ${1:Description} * * @author ${2:name} * @since ${3:`strftime("%d/%m/%y %H:%M:%S")`} */ ${0} # doc comment snippet docc /** * ${1:@private}$0 */ ${0} # class snippet class ${1:public }class ${2:`fnamemodify(bufname("%"),":t:r")`} ${3:extends} { //-------------------------------------- // CONSTRUCTOR //-------------------------------------- public $2 (${4:arguments}) { ${0:// expression} } } # package snippet package /** * ${1:Description} * * @author ${2:$TM_FULLNAME} * @since ${3:`strftime("%d/%m/%y %H:%M:%S")`} */ package ${0:package}; # function snippet fun ${1:void/private/protected/public}${2: static} ${3:name}(${4}) { ${5://if not void return null;} } ${0} snippet fn ${1:void }${2:name}(${3}) { ${4://if not void return null;} } ${0} # constant snippet const static final ${1:Object} ${2:VAR_NAM} = ${0}; # var snippet var ${1:private/public }${2:static }${3:String} ${4:str}${5: =}${0:value}; # var objects snippet obj ${1:private/public }${2:Object} ${3:o}${4: = new }$2(${0}); #loop for snippet for for (int ${2:i} = 0; $2 < ${1:Things}.length; $2${3:++}) { ${0:$1[$2]} }; #loop while snippet wh while (${1:/* condition */}) { ${0} } #break snippet break break ${1:label}; #case snippet case case ${1:expression} : ${0} break; #default snippet default default : ${1} break; #switch snippet switch switch(${1:expression}) { case '${3:case}': ${4} break; ${0} default: ${2} } #try snippet try try { ${0:${VISUAL}} } catch(${1:Exception} ${2:e}) { } #try catch finally snippet tryf try { ${0:${VISUAL}} } catch(${1:Exception} ${2:e}) { } finally { } #throw snippet throw throw new ("${1:Exception()}"); #ternary snippet ? ? ${1:trueExpression} : ${2:falseExpression} ${0} snippet if if (${1:true}) {${0}} # if ... else snippet ife if (${1:true}) {${2}} else{${0}} #get snippet get public ${1:String} get${2}() { return ${0:fieldName}; } #set snippet set public void set${1}(${0:String} new${1}) { ${1:fieldName} = new${1}; } #printIn snippet println println("${1:`fnamemodify(bufname("%"),":t:r")`}::${2:method}() "${3: +} ${0}); #println string snippet pr println("${0}"); #setup draw snippet setup void setup(){ ${1} } void draw(){ ${0} } #setup OPENGL snippet opengl import processing.opengl.*; import javax.media.opengl.*; PGraphicsOpenGL pgl; GL gl; void setup(){ size( ${1:300}, ${2:300}, OPENGL ); colorMode( RGB, 1.0 ); hint( ENABLE_OPENGL_4X_SMOOTH ); pgl = (PGraphicsOpenGL) g; gl = pgl.gl; gl.setSwapInterval(1); initGL(); ${3} } void draw(){ pgl.beginGL(); ${4} pgl.endGL(); getOpenGLErrors(); } void initGL(){ ${0} } void getOpenGLErrors(){ int error = gl.glGetError(); switch (error){ case 1280 : println("GL_INVALID_ENUM - An invalid enumerant was passed to an OpenGL command."); break; case 1282 : println("GL_INVALID_OPERATION - An OpenGL command was issued that was invalid or inappropriate for the current state."); break; case 1281 : println("GL_INVALID_VALUE - A value was passed to OpenGL that was outside the allowed range."); break; case 1285 : println("GL_OUT_OF_MEMORY - OpenGL was unable to allocate enough memory to process a command."); break; case 1283 : println("GL_STACK_OVERFLOW - A command caused an OpenGL stack to overflow."); break; case 1284 : println("GL_STACK_UNDERFLOW - A command caused an OpenGL stack to underflow."); break; case 32817 : println("GL_TABLE_TOO_LARGE"); break; } } #GL Functions snippet gl begin gl pgl.beginGL(); ${0} pgl.endGL(); snippet gl gl swap interval // specify the minimum swap interval for buffer swaps. gl.setSwapInterval(${0:interval}); snippet gl gl call list // execute a display list gl.glCallList(${0:list}); snippet gl gl gen buffers // import java.nio.IntBuffer; // import java.nio.FloatBuffer; // import com.sun.opengl.util.BufferUtil; // You might need to create four buffers to store vertext data, normal data, texture coordinate data, and indices in vertex arrays IntBuffer bufferObjects = IntBuffer.allocate(${1:4}); gl.glGenBuffers($1, bufferObjects); int vertexCount = ${2:3}; int numCoordinates = ${0:3}; // vertexCount * numCoordinates FloatBuffer vertices = BufferUtil.newFloatBuffer(vertexCount * numCoordinates); float[] v = {0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f}; vertices.put(v); // Bind the first buffer object ID for use with vertext array data gl.glBindBuffer(GL.GL_ARRAY_BUFFER, bufferObjects.get(0)); gl.glBufferData(GL.GL_ARRAY_BUFFER, vertexCount * numCoordinates * BufferUtil.SIZEOF_FLOAT, vertices, GL.GL_STATIC_DRAW); snippet gl gl bind buffer ${0:// A buffer ID of zero unbinds a buffer object} gl.glBindBuffer(GL.GL_ARRAY_BUFFER, ${1:0}); snippet gl gl delete buffers ${0:// Parameters are the same for glGenBuffers} gl.glDeleteBuffers(${1:4}, ${2:bufferObjects}); snippet gl gl depth mask // enable or disable writing into the depth buffer gl.glDepthMask(${0:flag}); snippet gl gl load identity // replaces the top of the active matrix stack with the identity matrix gl.glLoadIdentity(); snippet gl gl tex coord 2f // set the current texture coordinates - 2 floats gl.glTexCoord2f(${1:0.0f}, ${0:0.0f}); snippet gl gl vertex 2f gl.glVertex2f(${1:0.0f}, ${0:0.0f}); snippet gl gl vertex 3f gl.glVertex3f(${1:0.0f}, ${2:0.0f}, ${0:0.0f}); snippet gl gl translate f // multiply the current matrix by a translation matrix gl.glTranslatef(${1:x}, ${2:y}, ${0:z}); snippet gl gl rotate f // rotate, x-axis, y-axis, z-axiz gl.glRotatef(${1:angle}, ${2:x}, ${3:y}, ${0:z}); snippet gl gl scale f // multiply the current matrix by a general scaling matrix gl.glScalef(${1:x}, ${2:y}, ${0:z}); snippet gl gl color 4f gl.glColor4f(${1:red}, ${2:green}, ${3:blue}, ${0:alpha}); snippet gl gl clear color gl.glClearColor(${1:red}, ${2:green}, ${3:blue}, ${0:alpha}); snippet gl gl color 3f gl.glColor3f(${1:red}, ${2:green}, ${0:blue}); snippet gl gl push matrix // spush and pop the current matrix stack gl.glPushMatrix(); ${0} gl.glPopMatrix(); snippet gl gl gen lists gl.glGenLists(${0:1}) snippet gl gl flush // Empties buffers. Call this when all previous issues commands completed gl.glFlush(); ${0} snippet gl gl get error println(gl.glGetError()); snippet gl gl clear gl.glClear(${1:GL.GL_COLOR_BUFFER_BIT}${2: | }${0:GL.GL_DEPTH_BUFFER_BIT}); #frame operations snippet frameRate frameRate(${1:30}); ${0} snippet saveFrame saveFrame("${1:filename-####}${0:.ext}"); #size snippet size normal size(${1:200}, ${2:200}${0:, P3D}); snippet size opengl size(${1:200}, ${2:200}${0:, OPENGL}); #PRIMITIVES #color snippet color color ${1:c}${2: = color(}${3:value1, }${4:value2, }${0:value3)}; #char snippet char char ${1:m}${2: = "}${0:char"}; #float snippet float float ${1:f}${2: = }${0:0.0f}; #int snippet int int ${1:f}${2: = }${0:0}; #boolean snippet boolean boolean ${1:b}${2: = }${0:true}; #byte snippet byte byte ${1:b}${2: = }${0:127}; #string snippet string String ${1:str}${2: = "}${0:CCCP"}; #array snippet array ${1:int}[] ${2:numbers}${3: = new $1}[${0:length}]; #object snippet object ${1:Object} ${2:o}${3: = new $1}(${0}); #curve snippet curve curve(${1:x1}, ${2:y1}, ${3:x2}, ${4:y2}, ${5:x3}, ${6:y3}, ${7:x4}, ${0:y4}); snippet curve 3D curve(${1:x1}, ${2:y1}, ${3:z1}, ${4:x2}, ${5:y2}, ${6:z2}, ${7:x3}, ${8:y3}, ${9:z3}, ${10:x4}, ${11:y4}, ${0:z4}); snippet curveDetail curveDetail(${0:detail}); snippet curvePoint curvePoint(${1:a}, ${2:b}, ${3:c}, ${4:d}, ${0:t}); snippet curveTightness curveTightness(${0:squishy}); #bezier snippet bezier bezier(${1:x1}, ${2:y1}, ${3:cx1}, ${4:cy1}, ${5:cx2}, ${6:cy2}, ${7:x2}, ${0:y2}); snippet bezier 3D bezier(${1:x1}, ${2:y1}, ${3:z1}, ${4:cx1}, ${5:cy1}, ${6:cz1}, ${7:cx2}, ${8:cy2}, ${9:cz2}, ${10:x2}, ${11:y2}, ${0:z2}); snippet bezierDetail bezierDetail(${0:detail}); snippet bezierTangent bezierTangent(${1:a}, ${2:b}, ${3:c}, ${4:d}, ${0:t}); snippet bezierPoint bezierPoint(${1:a}, ${2:b}, ${3:c}, ${4:d}, ${0:t}); #vertex snippet vertex vertex(${1:x}, ${2:y}${3:, }${4:u}${5:, }${0:v}); snippet vertex 3D vertex(${1:x}, ${2:y}, ${3:z}${4:, }${5:u}${6:, }${0:v}); snippet bezierVertex bezierVertex(${1:cx1}, ${2:cy1}, ${3:cx2}, ${4:cy2}, ${5:x}, ${0:y}); snippet bezierVertex 3D bezierVertex(${1:cx1}, ${2:cy1}, ${3:cz1}, ${4:cx2}, ${5:cy2}, ${6:cz2}, ${7:x}, ${8:y}, ${0:z}); snippet curveVertex curveVertex(${1:x}, ${0:y}); snippet curveVertex 3D curveVertex(${1:x}, ${2:y}, ${0:z}); #stroke snippet stroke stroke(${1:value1}, ${2:value2}, ${3:value3}${4:, }${0:alpha}); snippet strokeWeight strokeWeight(${0:1}); #mouse snippet mouseDragged void mouseDragged(){ ${0} } snippet mouseMoved void mouseMoved(){ ${0} } snippet mouseReleased void mouseReleased(){ ${0} } snippet mousePressed void mousePressed(){ ${0} } #key snippet keyReleased void keyReleased(){ ${0} } snippet keyTyped void keyTyped(){ ${0} } snippet keyPressed void keyPressed(){ ${0} } #file snippet loadStrings loadStrings("${0:filename}"); snippet saveStrings saveStrings(${1:filename}, ${0:strings}); snippet loadBytes loadBytes("${0:filename}"); snippet beginRecord beginRecord(${1:renderer}, ${0:filename}); snippet saveBytes saveBytes(${1:filename}, ${0:bytes}); snippet createWriter createWriter(${0:filename}); snippet createReader createReader(${0:filename}); #matrix snippet pushMatrix pushMatrix(); ${0:}; popMatrix(); #text snippet text data text(${1:data}, ${2:x}, ${3:y}${4:, }${0:z}); snippet text stringdata text(${1:stringdata}, ${2:x}, ${3:y}, ${4:width}, ${5:height}${6:, }${0:z}); snippet textSize textSize(${0:size}); snippet textLeading textLeading(${0:size}); snippet textWidth textWidth(${0:data}); snippet font PFont ${1:font}; $1 = loadFont("${0:FFScala-32.vlw}"); #load font snippet loadFont ${1:font} = loadFont("${0:FFScala-32.vlw}"); snippet textFont textFont(${1:font}${2:, }${0:size}); #math snippet tan tan(${0:rad}); snippet atan atan(${0:rad}); snippet atan2 atan2(${0:rad}); snippet sin sin(${0:rad}); snippet asin asin(${0:rad}); snippet cos cos(${0:rad}); snippet acos acos(${0:rad}); snippet degrees degrees(${0:rad}); snippet radians radians(${0:deg}); snippet randomSseed randomSeed(${0:value}); snippet random random(${1:value1}${2:, }${0:value2}); snippet pow pow(${1:num}, ${0:exponent}); snippet floor floor(${0:value}); snippet sqrt sqrt(${0:value}); snippet abs abs(${0:value}); snippet sq sq(${0:value}); snippet ceil ceil(${0:value}); snippet exp exp(${0:value}); snippet round round(${0:value}}; snippet min min(${1:value1}, ${2:value2}${3:, }${0:value3}); snippet max max(${1:value1}, ${2:value2}${3:, }${0:value3}); snippet max array max(${0:array}); snippet min array min(${0:array}); snippet log log(${0:value}); snippet map map(${1:value}, ${2:low1}, ${4:high1}, ${5:low2}, ${0:high2}); snippet norm norm(${1:value}, ${2:low}, ${0:high}); snippet constrain constrain(${1:value}, ${2:min}, ${0:max}); snippet mag mag(${1:a}, ${2:b}${3:, }${0:c}); snippet dist dist(${1:x1}, ${2:y1}, ${4:x2}, ${0:y2}); snippet dist 3D dist(${1:x1}, ${2:y1}, ${3:z1}, ${4:x2}, ${5:y2}, ${0:z2}); #noise math snippet noise noise(${1:x}${2:, }${3:y}${4:, }${0:z}); snippet noiseDetail noiseDetail(${1:octaves}${2:, }${0:falloff}); snippet noiseSeed noiseSeed(${0:x}); #material snippet shininess shininess(${0:shine}); snippet specular specular(${1:value1}, ${2:value2}, ${3:value3}${4:, }${0:alpha}); snippet ambient ambient(${1:value1}, ${2:value2}, ${0:value3}); snippet emissive emissive(${1:value1}, ${2:value2}, ${0:value3}); #light snippet diretionalLight directionalLight(${1:v1}, ${2:v2}, ${3:v3}, ${4:nx}, ${5:ny}, ${0:nz}); snippet pointLight pointLight(${1:v1}, ${2:v2}, ${3:v3}, ${4:nx}, ${5:ny}, ${0:nz}); snippet lightFalloff lightFalloff(${1:constant}, ${2:linear}, ${0:quadratic}); snippet normal normal(${1:nx}, ${2:ny}, ${0:nz}); snippet lightSpecular lightSpecular(${1:v1}, ${2:v2}, ${0:v3}); snippet ambientLight ambientLight(${1:v1}, ${2:v2}, ${3:v3}${7:, ${4:x}, ${5:y}, ${0:z}}); snippet spotLight spotLight(${1:v1}, ${2:v2}, ${3:v3}, ${4:x}, ${5:y}, ${6:z}, ${7:nx}, ${8:ny}, ${9:nz}, ${10:angle}, ${0:concentration}); #camera snippet camera camera(${1:eyeX}, ${2:eyeY}, ${3:eyeZ}, ${4:centerX}, ${5:centerY}, ${6:centerZ}, ${7:upX}, ${8:upY}, ${0:upZ}); snippet ortho ortho(${1:left}, ${2:right}, ${3:bottom}, ${4:top}, ${5:near}, ${0:far}); snippet perspective perspective(${1:fov}, ${2:aspect}, ${3:zNear}, ${0:zFar}); snippet frustrum frustrum(${1:left}, ${2:right}, ${3:bottom}, ${4:top}, ${5:near}, ${0:far}); #transformations snippet rotate rotate${1:X}(${0:angle}); snippet translate translate(${1:x}, ${2:y}${3:, }${0:z}); snippet scale size scale(${0:size}); snippet scale scale(${1:x}, ${2:y}${3:, }${0:z}); #coordinates snippet coord ${1:model/screen}${2:X}(${3:x}, ${4:y}, ${0:z}); #effects snippet brightness brightness(${0:color}); snippet lerpColor lerpColor(${1:c1}, ${2:c2}, ${0:amt}); snippet saturation saturation(${0:color}); snippet hue hue(${0:color}); snippet alpha alpha(${0:color}); snippet tint tint(${1:value1}, ${2:value2}, ${3:value3}${4:, }${0:alpha}); #pixel snippet set pixel set(${1:x}, ${2:y}, ${0:color/image}); snippet pixels pixels[${0:index}] snippet get pixel get(${1:x}, ${2:y}${3:, }${4:width}${5:, }${0:height}); #geometric figures snippet triangle triangle(${1:x1}, ${2:y1}, ${3:x2}, ${4:y2}, ${5:x3}, ${0:y3}); snippet line line(${1:x1}, ${2:y1}, ${3:x2}, ${0:y2}); snippet line 3D line(${1:x1}, ${2:y1}, ${3:z1}, ${4:x2}, ${5:y2}, ${0:z2}); snippet arc arc(${1:x}, ${2:y}, ${3:width}, ${4:height}, ${5:start}, ${0:stop}); snippet point point(${1:x}, ${2:y}${3:, }${0:z}); snippet quad quad(${1:x1}, ${2:y1}, ${3:x2}, ${4:y2}, ${5:x3}, ${6:y3}, ${7:x4}, ${0:y4}); snippet ellipse ellipse(${1:x}, ${2:y}, ${3:width}, ${0:height}); snippet rect rect(${1:x}, ${2:y}, ${3:width}, ${0:height}); snippet box box(${1:width}, ${2:height}, ${0:depth}); snippet sphere sphere(${0:radius}); snippet sphereDetails sphereDetail(${0:n}); #array operations snippet split split("${1:str}"${2: , }${0:delimiter}); snippet splitTokens splitTokens(${1:str}${2:, }${0:tokens}); snippet join join(${1:strgArray}${2: , }${0:seperator}); snippet shorten shorten(${0:array}); snippet concat concat(${1:array1}, ${0:array2}); snippet subset subset(${1:array}, ${0:offset}); snippet append append(${1:array}, ${0:element}); snippet reverse reverse(${0:array}); snippet splice splice(${1:array}, ${2:value/array2}, ${0:index}); snippet sort sort(${1:dataArray}${2:, }${0:count}); snippet expand expand(${1:array}${2:, }${0:newSize}); snippet arrayCopy arrayCopy(${1:src}, ${2:dest}, ${3:, }${0:length}); #string operations snippet str str("${0:str}"); snippet match match(${1:str}, ${0:regexp}); snippet trim trim(${0:str}); snippet nf nf(${2:value}, ${3:left}${4:, }${0:right}); snippet nfs nfs(${2:value}, ${3:left}${4:, }${0:right}); snippet nfp nfp(${2:value}, ${3:left}${4:, }${0:right}); snippet nfc nfc(${1:value}${2:, }${0:right}); #convert snippet unbinary unbinary("${0:str}"}); snippet hexadecimal hex(${0:c}); snippet unhex unhex(${0:c}); snippet binary binary(${1:value}${2:, }${0:digits}); #image operations snippet loadImage loadImage(${0:filename}); snippet image image(${1:img}, ${2:x}, ${3:y}${4:, }${5:width}${6:, }${0:height}); snippet copy copy(${1:srcImg}${2:, }${3:x}, ${4:y}, ${5:width}, ${6:height}, ${7:dx}, ${8:dy}, ${9:dwidth}, ${0:dheight}); #containers snippet bg background(${1:value1}, ${2:value2}, ${3:value3}${4:, }${0:alpha}); snippet pg PGraphics pg; pg = createGraphics(${1:width}, ${2:height}${3:, }${0:applet}); snippet pimage PImage(${1:width}, ${0:height}); #UTILS #fill snippet fill fill(${1:value1}, ${2:value2}, ${3:value3}${4:, }${0:alpha}); #red snippet red red(${0:color}); #green snippet green green(${0:color}); #blue snippet blue blue(${0:color}); #status snippet status status(${0:text}); #param snippet param param(${0:s}); #link snippet link link(${1:url}${2:, }${0:target}); #@param snippet @ @${1:param/return/private/public} ${1:parameter} ${0:description}