ultimate-vim/sources_non_forked/vim-snippets/snippets/processing.snippets

#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}