Datasets:

---

CM

/

codexglue_code2text_java

like 4

[ "public", "void", "addFigure", "(", "Figure", "figure", ")", "{", "figures", ".", "add", "(", "figure", ")", ";", "figureMap", ".", "put", "(", "figure", ".", "getData", "(", ")", ".", "getAttribute", "(", "NonGeometricData", ".", "ID", ")", ",", "figure", ")", ";", "String", "fillRef", "=", "figure", ".", "getData", "(", ")", ".", "getAsReference", "(", "NonGeometricData", ".", "FILL", ")", ";", "Gradient", "gradient", "=", "getGradient", "(", "fillRef", ")", ";", "if", "(", "gradient", "!=", "null", ")", "{", "if", "(", "gradient", ".", "isRadial", "(", ")", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "InkscapeLoader", ".", "RADIAL_TRIANGULATION_LEVEL", ";", "i", "++", ")", "{", "figure", ".", "getShape", "(", ")", ".", "increaseTriangulation", "(", ")", ";", "}", "}", "}", "}" ]

[ "Add", "a", "figure", "to", "the", "diagram" ]

[ "public", "void", "removeFigure", "(", "Figure", "figure", ")", "{", "figures", ".", "remove", "(", "figure", ")", ";", "figureMap", ".", "remove", "(", "figure", ".", "getData", "(", ")", ".", "getAttribute", "(", "\"id\"", ")", ")", ";", "}" ]

[ "Remove", "a", "figure", "from", "the", "diagram" ]

[ "public", "void", "resolve", "(", "Diagram", "diagram", ")", "{", "if", "(", "ref", "==", "null", ")", "{", "return", ";", "}", "Gradient", "other", "=", "diagram", ".", "getGradient", "(", "ref", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "other", ".", "steps", ".", "size", "(", ")", ";", "i", "++", ")", "{", "steps", ".", "add", "(", "other", ".", "steps", ".", "get", "(", "i", ")", ")", ";", "}", "}" ]

[ "Resolve", "the", "gradient", "reference" ]

[ "public", "void", "genImage", "(", ")", "{", "if", "(", "image", "==", "null", ")", "{", "ImageBuffer", "buffer", "=", "new", "ImageBuffer", "(", "128", ",", "16", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "128", ";", "i", "++", ")", "{", "Color", "col", "=", "getColorAt", "(", "i", "/", "128.0f", ")", ";", "for", "(", "int", "j", "=", "0", ";", "j", "<", "16", ";", "j", "++", ")", "{", "buffer", ".", "setRGBA", "(", "i", ",", "j", ",", "col", ".", "getRedByte", "(", ")", ",", "col", ".", "getGreenByte", "(", ")", ",", "col", ".", "getBlueByte", "(", ")", ",", "col", ".", "getAlphaByte", "(", ")", ")", ";", "}", "}", "image", "=", "buffer", ".", "getImage", "(", ")", ";", "}", "}" ]

[ "Generate", "the", "image", "used", "for", "texturing", "the", "gradient", "across", "shapes" ]

[ "public", "Color", "getColorAt", "(", "float", "p", ")", "{", "if", "(", "p", "<=", "0", ")", "{", "return", "(", "(", "Step", ")", "steps", ".", "get", "(", "0", ")", ")", ".", "col", ";", "}", "if", "(", "p", ">", "1", ")", "{", "return", "(", "(", "Step", ")", "steps", ".", "get", "(", "steps", ".", "size", "(", ")", "-", "1", ")", ")", ".", "col", ";", "}", "for", "(", "int", "i", "=", "1", ";", "i", "<", "steps", ".", "size", "(", ")", ";", "i", "++", ")", "{", "Step", "prev", "=", "(", "(", "Step", ")", "steps", ".", "get", "(", "i", "-", "1", ")", ")", ";", "Step", "current", "=", "(", "(", "Step", ")", "steps", ".", "get", "(", "i", ")", ")", ";", "if", "(", "p", "<=", "current", ".", "location", ")", "{", "float", "dis", "=", "current", ".", "location", "-", "prev", ".", "location", ";", "p", "-=", "prev", ".", "location", ";", "float", "v", "=", "p", "/", "dis", ";", "Color", "c", "=", "new", "Color", "(", "1", ",", "1", ",", "1", ",", "1", ")", ";", "c", ".", "a", "=", "(", "prev", ".", "col", ".", "a", "*", "(", "1", "-", "v", ")", ")", "+", "(", "current", ".", "col", ".", "a", "*", "(", "v", ")", ")", ";", "c", ".", "r", "=", "(", "prev", ".", "col", ".", "r", "*", "(", "1", "-", "v", ")", ")", "+", "(", "current", ".", "col", ".", "r", "*", "(", "v", ")", ")", ";", "c", ".", "g", "=", "(", "prev", ".", "col", ".", "g", "*", "(", "1", "-", "v", ")", ")", "+", "(", "current", ".", "col", ".", "g", "*", "(", "v", ")", ")", ";", "c", ".", "b", "=", "(", "prev", ".", "col", ".", "b", "*", "(", "1", "-", "v", ")", ")", "+", "(", "current", ".", "col", ".", "b", "*", "(", "v", ")", ")", ";", "return", "c", ";", "}", "}", "// shouldn't ever happen\r", "return", "Color", ".", "black", ";", "}" ]

[ "Get", "the", "intepolated", "colour", "at", "the", "given", "location", "on", "the", "gradient" ]

[ "public", "void", "setDisplayMode", "(", "int", "width", ",", "int", "height", ",", "boolean", "fullscreen", ")", "throws", "SlickException", "{", "if", "(", "(", "this", ".", "width", "==", "width", ")", "&&", "(", "this", ".", "height", "==", "height", ")", "&&", "(", "isFullscreen", "(", ")", "==", "fullscreen", ")", ")", "{", "return", ";", "}", "try", "{", "targetDisplayMode", "=", "null", ";", "if", "(", "fullscreen", ")", "{", "DisplayMode", "[", "]", "modes", "=", "Display", ".", "getAvailableDisplayModes", "(", ")", ";", "int", "freq", "=", "0", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "modes", ".", "length", ";", "i", "++", ")", "{", "DisplayMode", "current", "=", "modes", "[", "i", "]", ";", "if", "(", "(", "current", ".", "getWidth", "(", ")", "==", "width", ")", "&&", "(", "current", ".", "getHeight", "(", ")", "==", "height", ")", ")", "{", "if", "(", "(", "targetDisplayMode", "==", "null", ")", "||", "(", "current", ".", "getFrequency", "(", ")", ">=", "freq", ")", ")", "{", "if", "(", "(", "targetDisplayMode", "==", "null", ")", "||", "(", "current", ".", "getBitsPerPixel", "(", ")", ">", "targetDisplayMode", ".", "getBitsPerPixel", "(", ")", ")", ")", "{", "targetDisplayMode", "=", "current", ";", "freq", "=", "targetDisplayMode", ".", "getFrequency", "(", ")", ";", "}", "}", "// if we've found a match for bpp and frequence against the \r", "// original display mode then it's probably best to go for this one\r", "// since it's most likely compatible with the monitor\r", "if", "(", "(", "current", ".", "getBitsPerPixel", "(", ")", "==", "originalDisplayMode", ".", "getBitsPerPixel", "(", ")", ")", "&&", "(", "current", ".", "getFrequency", "(", ")", "==", "originalDisplayMode", ".", "getFrequency", "(", ")", ")", ")", "{", "targetDisplayMode", "=", "current", ";", "break", ";", "}", "}", "}", "}", "else", "{", "targetDisplayMode", "=", "new", "DisplayMode", "(", "width", ",", "height", ")", ";", "}", "if", "(", "targetDisplayMode", "==", "null", ")", "{", "throw", "new", "SlickException", "(", "\"Failed to find value mode: \"", "+", "width", "+", "\"x\"", "+", "height", "+", "\" fs=\"", "+", "fullscreen", ")", ";", "}", "this", ".", "width", "=", "width", ";", "this", ".", "height", "=", "height", ";", "Display", ".", "setDisplayMode", "(", "targetDisplayMode", ")", ";", "Display", ".", "setFullscreen", "(", "fullscreen", ")", ";", "if", "(", "Display", ".", "isCreated", "(", ")", ")", "{", "initGL", "(", ")", ";", "enterOrtho", "(", ")", ";", "}", "if", "(", "targetDisplayMode", ".", "getBitsPerPixel", "(", ")", "==", "16", ")", "{", "InternalTextureLoader", ".", "get", "(", ")", ".", "set16BitMode", "(", ")", ";", "}", "}", "catch", "(", "LWJGLException", "e", ")", "{", "throw", "new", "SlickException", "(", "\"Unable to setup mode \"", "+", "width", "+", "\"x\"", "+", "height", "+", "\" fullscreen=\"", "+", "fullscreen", ",", "e", ")", ";", "}", "getDelta", "(", ")", ";", "}" ]

[ "Set", "the", "display", "mode", "to", "be", "used" ]

[ "public", "void", "setFullscreen", "(", "boolean", "fullscreen", ")", "throws", "SlickException", "{", "if", "(", "isFullscreen", "(", ")", "==", "fullscreen", ")", "{", "return", ";", "}", "if", "(", "!", "fullscreen", ")", "{", "try", "{", "Display", ".", "setFullscreen", "(", "fullscreen", ")", ";", "}", "catch", "(", "LWJGLException", "e", ")", "{", "throw", "new", "SlickException", "(", "\"Unable to set fullscreen=\"", "+", "fullscreen", ",", "e", ")", ";", "}", "}", "else", "{", "setDisplayMode", "(", "width", ",", "height", ",", "fullscreen", ")", ";", "}", "getDelta", "(", ")", ";", "}" ]

[ "Indicate", "whether", "we", "want", "to", "be", "in", "fullscreen", "mode", ".", "Note", "that", "the", "current", "display", "mode", "must", "be", "valid", "as", "a", "fullscreen", "mode", "for", "this", "to", "work" ]

[ "private", "void", "tryCreateDisplay", "(", "PixelFormat", "format", ")", "throws", "LWJGLException", "{", "if", "(", "SHARED_DRAWABLE", "==", "null", ")", "{", "Display", ".", "create", "(", "format", ")", ";", "}", "else", "{", "Display", ".", "create", "(", "format", ",", "SHARED_DRAWABLE", ")", ";", "}", "}" ]

[ "Try", "creating", "a", "display", "with", "the", "given", "format" ]

[ "public", "void", "start", "(", ")", "throws", "SlickException", "{", "try", "{", "setup", "(", ")", ";", "getDelta", "(", ")", ";", "while", "(", "running", "(", ")", ")", "{", "gameLoop", "(", ")", ";", "}", "}", "finally", "{", "destroy", "(", ")", ";", "}", "if", "(", "forceExit", ")", "{", "System", ".", "exit", "(", "0", ")", ";", "}", "}" ]

[ "Start", "running", "the", "game" ]

[ "protected", "void", "setup", "(", ")", "throws", "SlickException", "{", "if", "(", "targetDisplayMode", "==", "null", ")", "{", "setDisplayMode", "(", "640", ",", "480", ",", "false", ")", ";", "}", "Display", ".", "setTitle", "(", "game", ".", "getTitle", "(", ")", ")", ";", "Log", ".", "info", "(", "\"LWJGL Version: \"", "+", "Sys", ".", "getVersion", "(", ")", ")", ";", "Log", ".", "info", "(", "\"OriginalDisplayMode: \"", "+", "originalDisplayMode", ")", ";", "Log", ".", "info", "(", "\"TargetDisplayMode: \"", "+", "targetDisplayMode", ")", ";", "AccessController", ".", "doPrivileged", "(", "new", "PrivilegedAction", "(", ")", "{", "public", "Object", "run", "(", ")", "{", "try", "{", "PixelFormat", "format", "=", "new", "PixelFormat", "(", "8", ",", "8", ",", "stencil", "?", "8", ":", "0", ",", "samples", ")", ";", "tryCreateDisplay", "(", "format", ")", ";", "supportsMultiSample", "=", "true", ";", "}", "catch", "(", "Exception", "e", ")", "{", "Display", ".", "destroy", "(", ")", ";", "try", "{", "PixelFormat", "format", "=", "new", "PixelFormat", "(", "8", ",", "8", ",", "stencil", "?", "8", ":", "0", ")", ";", "tryCreateDisplay", "(", "format", ")", ";", "alphaSupport", "=", "false", ";", "}", "catch", "(", "Exception", "e2", ")", "{", "Display", ".", "destroy", "(", ")", ";", "// if we couldn't get alpha, let us know\r", "try", "{", "tryCreateDisplay", "(", "new", "PixelFormat", "(", ")", ")", ";", "}", "catch", "(", "Exception", "e3", ")", "{", "Log", ".", "error", "(", "e3", ")", ";", "}", "}", "}", "return", "null", ";", "}", "}", ")", ";", "if", "(", "!", "Display", ".", "isCreated", "(", ")", ")", "{", "throw", "new", "SlickException", "(", "\"Failed to initialise the LWJGL display\"", ")", ";", "}", "initSystem", "(", ")", ";", "enterOrtho", "(", ")", ";", "try", "{", "getInput", "(", ")", ".", "initControllers", "(", ")", ";", "}", "catch", "(", "SlickException", "e", ")", "{", "Log", ".", "info", "(", "\"Controllers not available\"", ")", ";", "}", "catch", "(", "Throwable", "e", ")", "{", "Log", ".", "info", "(", "\"Controllers not available\"", ")", ";", "}", "try", "{", "game", ".", "init", "(", "this", ")", ";", "}", "catch", "(", "SlickException", "e", ")", "{", "Log", ".", "error", "(", "e", ")", ";", "running", "=", "false", ";", "}", "}" ]

[ "Setup", "the", "environment" ]

[ "protected", "void", "gameLoop", "(", ")", "throws", "SlickException", "{", "int", "delta", "=", "getDelta", "(", ")", ";", "if", "(", "!", "Display", ".", "isVisible", "(", ")", "&&", "updateOnlyOnVisible", ")", "{", "try", "{", "Thread", ".", "sleep", "(", "100", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "}", "}", "else", "{", "try", "{", "updateAndRender", "(", "delta", ")", ";", "}", "catch", "(", "SlickException", "e", ")", "{", "Log", ".", "error", "(", "e", ")", ";", "running", "=", "false", ";", "return", ";", "}", "}", "updateFPS", "(", ")", ";", "Display", ".", "update", "(", ")", ";", "if", "(", "Display", ".", "isCloseRequested", "(", ")", ")", "{", "if", "(", "game", ".", "closeRequested", "(", ")", ")", "{", "running", "=", "false", ";", "}", "}", "}" ]

[ "Strategy", "for", "overloading", "game", "loop", "context", "handling" ]

[ "static", "NonGeometricData", "getNonGeometricData", "(", "Element", "element", ")", "{", "String", "meta", "=", "getMetaData", "(", "element", ")", ";", "NonGeometricData", "data", "=", "new", "InkscapeNonGeometricData", "(", "meta", ",", "element", ")", ";", "data", ".", "addAttribute", "(", "NonGeometricData", ".", "ID", ",", "element", ".", "getAttribute", "(", "\"id\"", ")", ")", ";", "data", ".", "addAttribute", "(", "NonGeometricData", ".", "FILL", ",", "getStyle", "(", "element", ",", "NonGeometricData", ".", "FILL", ")", ")", ";", "data", ".", "addAttribute", "(", "NonGeometricData", ".", "STROKE", ",", "getStyle", "(", "element", ",", "NonGeometricData", ".", "STROKE", ")", ")", ";", "data", ".", "addAttribute", "(", "NonGeometricData", ".", "OPACITY", ",", "getStyle", "(", "element", ",", "NonGeometricData", ".", "OPACITY", ")", ")", ";", "data", ".", "addAttribute", "(", "NonGeometricData", ".", "STROKE_DASHARRAY", ",", "getStyle", "(", "element", ",", "NonGeometricData", ".", "STROKE_DASHARRAY", ")", ")", ";", "data", ".", "addAttribute", "(", "NonGeometricData", ".", "STROKE_DASHOFFSET", ",", "getStyle", "(", "element", ",", "NonGeometricData", ".", "STROKE_DASHOFFSET", ")", ")", ";", "data", ".", "addAttribute", "(", "NonGeometricData", ".", "STROKE_MITERLIMIT", ",", "getStyle", "(", "element", ",", "NonGeometricData", ".", "STROKE_MITERLIMIT", ")", ")", ";", "data", ".", "addAttribute", "(", "NonGeometricData", ".", "STROKE_OPACITY", ",", "getStyle", "(", "element", ",", "NonGeometricData", ".", "STROKE_OPACITY", ")", ")", ";", "data", ".", "addAttribute", "(", "NonGeometricData", ".", "STROKE_WIDTH", ",", "getStyle", "(", "element", ",", "NonGeometricData", ".", "STROKE_WIDTH", ")", ")", ";", "return", "data", ";", "}" ]

[ "Get", "the", "non", "-", "geometric", "data", "information", "from", "an", "XML", "element" ]

[ "static", "String", "getMetaData", "(", "Element", "element", ")", "{", "String", "label", "=", "element", ".", "getAttributeNS", "(", "INKSCAPE", ",", "\"label\"", ")", ";", "if", "(", "(", "label", "!=", "null", ")", "&&", "(", "!", "label", ".", "equals", "(", "\"\"", ")", ")", ")", "{", "return", "label", ";", "}", "return", "element", ".", "getAttribute", "(", "\"id\"", ")", ";", "}" ]

[ "Get", "the", "meta", "data", "store", "within", "an", "element", "either", "in", "the", "label", "or", "id", "atributes" ]

[ "static", "String", "extractStyle", "(", "String", "style", ",", "String", "attribute", ")", "{", "if", "(", "style", "==", "null", ")", "{", "return", "\"\"", ";", "}", "StringTokenizer", "tokens", "=", "new", "StringTokenizer", "(", "style", ",", "\";\"", ")", ";", "while", "(", "tokens", ".", "hasMoreTokens", "(", ")", ")", "{", "String", "token", "=", "tokens", ".", "nextToken", "(", ")", ";", "String", "key", "=", "token", ".", "substring", "(", "0", ",", "token", ".", "indexOf", "(", "'", "'", ")", ")", ";", "if", "(", "key", ".", "equals", "(", "attribute", ")", ")", "{", "return", "token", ".", "substring", "(", "token", ".", "indexOf", "(", "'", "'", ")", "+", "1", ")", ";", "}", "}", "return", "\"\"", ";", "}" ]

[ "Extract", "the", "style", "value", "from", "a", "Inkscape", "encoded", "string" ]

[ "static", "Transform", "getTransform", "(", "Element", "element", ",", "String", "attribute", ")", "{", "String", "str", "=", "element", ".", "getAttribute", "(", "attribute", ")", ";", "if", "(", "str", "==", "null", ")", "{", "return", "new", "Transform", "(", ")", ";", "}", "if", "(", "str", ".", "equals", "(", "\"\"", ")", ")", "{", "return", "new", "Transform", "(", ")", ";", "}", "else", "if", "(", "str", ".", "startsWith", "(", "\"translate\"", ")", ")", "{", "str", "=", "str", ".", "substring", "(", "0", ",", "str", ".", "length", "(", ")", "-", "1", ")", ";", "str", "=", "str", ".", "substring", "(", "\"translate(\"", ".", "length", "(", ")", ")", ";", "StringTokenizer", "tokens", "=", "new", "StringTokenizer", "(", "str", ",", "\", \"", ")", ";", "float", "x", "=", "Float", ".", "parseFloat", "(", "tokens", ".", "nextToken", "(", ")", ")", ";", "float", "y", "=", "Float", ".", "parseFloat", "(", "tokens", ".", "nextToken", "(", ")", ")", ";", "return", "Transform", ".", "createTranslateTransform", "(", "x", ",", "y", ")", ";", "}", "else", "if", "(", "str", ".", "startsWith", "(", "\"matrix\"", ")", ")", "{", "float", "[", "]", "pose", "=", "new", "float", "[", "6", "]", ";", "str", "=", "str", ".", "substring", "(", "0", ",", "str", ".", "length", "(", ")", "-", "1", ")", ";", "str", "=", "str", ".", "substring", "(", "\"matrix(\"", ".", "length", "(", ")", ")", ";", "StringTokenizer", "tokens", "=", "new", "StringTokenizer", "(", "str", ",", "\", \"", ")", ";", "float", "[", "]", "tr", "=", "new", "float", "[", "6", "]", ";", "for", "(", "int", "j", "=", "0", ";", "j", "<", "tr", ".", "length", ";", "j", "++", ")", "{", "tr", "[", "j", "]", "=", "Float", ".", "parseFloat", "(", "tokens", ".", "nextToken", "(", ")", ")", ";", "}", "pose", "[", "0", "]", "=", "tr", "[", "0", "]", ";", "pose", "[", "1", "]", "=", "tr", "[", "2", "]", ";", "pose", "[", "2", "]", "=", "tr", "[", "4", "]", ";", "pose", "[", "3", "]", "=", "tr", "[", "1", "]", ";", "pose", "[", "4", "]", "=", "tr", "[", "3", "]", ";", "pose", "[", "5", "]", "=", "tr", "[", "5", "]", ";", "return", "new", "Transform", "(", "pose", ")", ";", "}", "return", "new", "Transform", "(", ")", ";", "}" ]

[ "Get", "a", "transform", "defined", "in", "the", "XML" ]

[ "static", "float", "getFloatAttribute", "(", "Element", "element", ",", "String", "attr", ")", "throws", "ParsingException", "{", "String", "cx", "=", "element", ".", "getAttribute", "(", "attr", ")", ";", "if", "(", "(", "cx", "==", "null", ")", "||", "(", "cx", ".", "equals", "(", "\"\"", ")", ")", ")", "{", "cx", "=", "element", ".", "getAttributeNS", "(", "SODIPODI", ",", "attr", ")", ";", "}", "try", "{", "return", "Float", ".", "parseFloat", "(", "cx", ")", ";", "}", "catch", "(", "NumberFormatException", "e", ")", "{", "throw", "new", "ParsingException", "(", "element", ",", "\"Invalid value for: \"", "+", "attr", ",", "e", ")", ";", "}", "}" ]

[ "Get", "a", "floating", "point", "attribute", "that", "may", "appear", "in", "either", "the", "default", "or", "SODIPODI", "namespace" ]

[ "public", "static", "boolean", "validFill", "(", "Shape", "shape", ")", "{", "if", "(", "shape", ".", "getTriangles", "(", ")", "==", "null", ")", "{", "return", "false", ";", "}", "return", "shape", ".", "getTriangles", "(", ")", ".", "getTriangleCount", "(", ")", "!=", "0", ";", "}" ]

[ "Check", "there", "are", "enough", "points", "to", "fill" ]

[ "public", "static", "final", "void", "textureFit", "(", "Shape", "shape", ",", "final", "Image", "image", ",", "final", "float", "scaleX", ",", "final", "float", "scaleY", ")", "{", "if", "(", "!", "validFill", "(", "shape", ")", ")", "{", "return", ";", "}", "float", "points", "[", "]", "=", "shape", ".", "getPoints", "(", ")", ";", "Texture", "t", "=", "TextureImpl", ".", "getLastBind", "(", ")", ";", "image", ".", "getTexture", "(", ")", ".", "bind", "(", ")", ";", "final", "float", "minX", "=", "shape", ".", "getX", "(", ")", ";", "final", "float", "minY", "=", "shape", ".", "getY", "(", ")", ";", "final", "float", "maxX", "=", "shape", ".", "getMaxX", "(", ")", "-", "minX", ";", "final", "float", "maxY", "=", "shape", ".", "getMaxY", "(", ")", "-", "minY", ";", "fill", "(", "shape", ",", "new", "PointCallback", "(", ")", "{", "public", "float", "[", "]", "preRenderPoint", "(", "Shape", "shape", ",", "float", "x", ",", "float", "y", ")", "{", "x", "-=", "shape", ".", "getMinX", "(", ")", ";", "y", "-=", "shape", ".", "getMinY", "(", ")", ";", "x", "/=", "(", "shape", ".", "getMaxX", "(", ")", "-", "shape", ".", "getMinX", "(", ")", ")", ";", "y", "/=", "(", "shape", ".", "getMaxY", "(", ")", "-", "shape", ".", "getMinY", "(", ")", ")", ";", "float", "tx", "=", "x", "*", "scaleX", ";", "float", "ty", "=", "y", "*", "scaleY", ";", "tx", "=", "image", ".", "getTextureOffsetX", "(", ")", "+", "(", "image", ".", "getTextureWidth", "(", ")", "*", "tx", ")", ";", "ty", "=", "image", ".", "getTextureOffsetY", "(", ")", "+", "(", "image", ".", "getTextureHeight", "(", ")", "*", "ty", ")", ";", "GL", ".", "glTexCoord2f", "(", "tx", ",", "ty", ")", ";", "return", "null", ";", "}", "}", ")", ";", "if", "(", "t", "==", "null", ")", "{", "TextureImpl", ".", "bindNone", "(", ")", ";", "}", "else", "{", "t", ".", "bind", "(", ")", ";", "}", "}" ]

[ "Draw", "the", "the", "given", "shape", "filled", "in", "with", "a", "texture", ".", "Only", "the", "vertices", "are", "set", ".", "The", "colour", "has", "to", "be", "set", "independently", "of", "this", "method", ".", "This", "method", "is", "required", "to", "fit", "the", "texture", "scaleX", "times", "across", "the", "shape", "and", "scaleY", "times", "down", "the", "shape", "." ]

[ "public", "int", "playAsSoundEffect", "(", "float", "pitch", ",", "float", "gain", ",", "boolean", "loop", ",", "float", "x", ",", "float", "y", ",", "float", "z", ")", "{", "checkTarget", "(", ")", ";", "return", "target", ".", "playAsSoundEffect", "(", "pitch", ",", "gain", ",", "loop", ",", "x", ",", "y", ",", "z", ")", ";", "}" ]

[ "Play", "this", "sound", "as", "a", "sound", "effect" ]

[ "public", "void", "set", "(", "Vector2f", "start", ",", "Vector2f", "end", ")", "{", "super", ".", "pointsDirty", "=", "true", ";", "if", "(", "this", ".", "start", "==", "null", ")", "{", "this", ".", "start", "=", "new", "Vector2f", "(", ")", ";", "}", "this", ".", "start", ".", "set", "(", "start", ")", ";", "if", "(", "this", ".", "end", "==", "null", ")", "{", "this", ".", "end", "=", "new", "Vector2f", "(", ")", ";", "}", "this", ".", "end", ".", "set", "(", "end", ")", ";", "vec", "=", "new", "Vector2f", "(", "end", ")", ";", "vec", ".", "sub", "(", "start", ")", ";", "lenSquared", "=", "vec", ".", "lengthSquared", "(", ")", ";", "}" ]

[ "Configure", "the", "line" ]

[ "public", "void", "set", "(", "float", "sx", ",", "float", "sy", ",", "float", "ex", ",", "float", "ey", ")", "{", "super", ".", "pointsDirty", "=", "true", ";", "start", ".", "set", "(", "sx", ",", "sy", ")", ";", "end", ".", "set", "(", "ex", ",", "ey", ")", ";", "float", "dx", "=", "(", "ex", "-", "sx", ")", ";", "float", "dy", "=", "(", "ey", "-", "sy", ")", ";", "vec", ".", "set", "(", "dx", ",", "dy", ")", ";", "lenSquared", "=", "(", "dx", "*", "dx", ")", "+", "(", "dy", "*", "dy", ")", ";", "}" ]

[ "Configure", "the", "line", "without", "garbage" ]

[ "public", "float", "distanceSquared", "(", "Vector2f", "point", ")", "{", "getClosestPoint", "(", "point", ",", "closest", ")", ";", "closest", ".", "sub", "(", "point", ")", ";", "float", "result", "=", "closest", ".", "lengthSquared", "(", ")", ";", "return", "result", ";", "}" ]

[ "Get", "the", "shortest", "distance", "squared", "from", "a", "point", "to", "this", "line" ]

[ "public", "void", "getClosestPoint", "(", "Vector2f", "point", ",", "Vector2f", "result", ")", "{", "loc", ".", "set", "(", "point", ")", ";", "loc", ".", "sub", "(", "start", ")", ";", "float", "projDistance", "=", "vec", ".", "dot", "(", "loc", ")", ";", "projDistance", "/=", "vec", ".", "lengthSquared", "(", ")", ";", "if", "(", "projDistance", "<", "0", ")", "{", "result", ".", "set", "(", "start", ")", ";", "return", ";", "}", "if", "(", "projDistance", ">", "1", ")", "{", "result", ".", "set", "(", "end", ")", ";", "return", ";", "}", "result", ".", "x", "=", "start", ".", "getX", "(", ")", "+", "projDistance", "*", "vec", ".", "getX", "(", ")", ";", "result", ".", "y", "=", "start", ".", "getY", "(", ")", "+", "projDistance", "*", "vec", ".", "getY", "(", ")", ";", "}" ]

[ "Get", "the", "closest", "point", "on", "the", "line", "to", "a", "given", "point" ]

[ "private", "void", "init", "(", "InputStream", "in", ")", "throws", "java", ".", "io", ".", "IOException", "{", "if", "(", "in", ".", "available", "(", ")", ">", "2000000", ")", "{", "throw", "new", "IOException", "(", "\"Font too big\"", ")", ";", "}", "this", ".", "file", "=", "IOUtils", ".", "toByteArray", "(", "in", ")", ";", "this", ".", "fsize", "=", "this", ".", "file", ".", "length", ";", "if", "(", "fsize", ">", "2000000", ")", "{", "throw", "new", "IOException", "(", "\"Font too big\"", ")", ";", "}", "this", ".", "current", "=", "0", ";", "}" ]

[ "Initializes", "class", "and", "reads", "stream", ".", "Init", "does", "not", "close", "stream", "." ]

[ "public", "void", "seekSet", "(", "long", "offset", ")", "throws", "IOException", "{", "if", "(", "offset", ">=", "fsize", "||", "offset", "<", "0", ")", "{", "throw", "new", "java", ".", "io", ".", "EOFException", "(", "\"Reached EOF, file size=\"", "+", "fsize", "+", "\" offset=\"", "+", "offset", ")", ";", "}", "current", "=", "(", "int", ")", "offset", ";", "}" ]

[ "Set", "current", "file", "position", "to", "offset" ]

[ "public", "byte", "read", "(", ")", "throws", "IOException", "{", "if", "(", "current", ">=", "fsize", ")", "{", "throw", "new", "java", ".", "io", ".", "EOFException", "(", "\"Reached EOF, file size=\"", "+", "fsize", ")", ";", "}", "final", "byte", "ret", "=", "file", "[", "current", "++", "]", ";", "return", "ret", ";", "}" ]

[ "Read", "1", "byte", "." ]

[ "public", "final", "void", "writeTTFUShort", "(", "int", "pos", ",", "int", "val", ")", "throws", "IOException", "{", "if", "(", "(", "pos", "+", "2", ")", ">", "fsize", ")", "{", "throw", "new", "java", ".", "io", ".", "EOFException", "(", "\"Reached EOF\"", ")", ";", "}", "final", "byte", "b1", "=", "(", "byte", ")", "(", "(", "val", ">>", "8", ")", "&", "0xff", ")", ";", "final", "byte", "b2", "=", "(", "byte", ")", "(", "val", "&", "0xff", ")", ";", "file", "[", "pos", "]", "=", "b1", ";", "file", "[", "pos", "+", "1", "]", "=", "b2", ";", "}" ]

[ "Write", "a", "USHort", "at", "a", "given", "position", "." ]

[ "public", "final", "short", "readTTFShort", "(", "long", "pos", ")", "throws", "IOException", "{", "final", "long", "cp", "=", "getCurrentPos", "(", ")", ";", "seekSet", "(", "pos", ")", ";", "final", "short", "ret", "=", "readTTFShort", "(", ")", ";", "seekSet", "(", "cp", ")", ";", "return", "ret", ";", "}" ]

[ "Read", "2", "bytes", "signed", "at", "position", "pos", "without", "changing", "current", "position", "." ]

[ "public", "final", "int", "readTTFUShort", "(", "long", "pos", ")", "throws", "IOException", "{", "long", "cp", "=", "getCurrentPos", "(", ")", ";", "seekSet", "(", "pos", ")", ";", "int", "ret", "=", "readTTFUShort", "(", ")", ";", "seekSet", "(", "cp", ")", ";", "return", "ret", ";", "}" ]

[ "Read", "2", "bytes", "unsigned", "at", "position", "pos", "without", "changing", "current", "position", "." ]

[ "public", "final", "String", "readTTFString", "(", ")", "throws", "IOException", "{", "int", "i", "=", "current", ";", "while", "(", "file", "[", "i", "++", "]", "!=", "0", ")", "{", "if", "(", "i", ">", "fsize", ")", "{", "throw", "new", "java", ".", "io", ".", "EOFException", "(", "\"Reached EOF, file size=\"", "+", "fsize", ")", ";", "}", "}", "byte", "[", "]", "tmp", "=", "new", "byte", "[", "i", "-", "current", "]", ";", "System", ".", "arraycopy", "(", "file", ",", "current", ",", "tmp", ",", "0", ",", "i", "-", "current", ")", ";", "return", "new", "String", "(", "tmp", ",", "\"ISO-8859-1\"", ")", ";", "}" ]

[ "Read", "a", "NUL", "terminated", "ISO", "-", "8859", "-", "1", "string", "." ]

[ "public", "final", "String", "readTTFString", "(", "int", "len", ")", "throws", "IOException", "{", "if", "(", "(", "len", "+", "current", ")", ">", "fsize", ")", "{", "throw", "new", "java", ".", "io", ".", "EOFException", "(", "\"Reached EOF, file size=\"", "+", "fsize", ")", ";", "}", "byte", "[", "]", "tmp", "=", "new", "byte", "[", "len", "]", ";", "System", ".", "arraycopy", "(", "file", ",", "current", ",", "tmp", ",", "0", ",", "len", ")", ";", "current", "+=", "len", ";", "final", "String", "encoding", ";", "if", "(", "(", "tmp", ".", "length", ">", "0", ")", "&&", "(", "tmp", "[", "0", "]", "==", "0", ")", ")", "{", "encoding", "=", "\"UTF-16BE\"", ";", "}", "else", "{", "encoding", "=", "\"ISO-8859-1\"", ";", "}", "return", "new", "String", "(", "tmp", ",", "encoding", ")", ";", "}" ]

[ "Read", "an", "ISO", "-", "8859", "-", "1", "string", "of", "len", "bytes", "." ]

[ "public", "byte", "[", "]", "getBytes", "(", "int", "offset", ",", "int", "length", ")", "throws", "IOException", "{", "if", "(", "(", "offset", "+", "length", ")", ">", "fsize", ")", "{", "throw", "new", "java", ".", "io", ".", "IOException", "(", "\"Reached EOF\"", ")", ";", "}", "byte", "[", "]", "ret", "=", "new", "byte", "[", "length", "]", ";", "System", ".", "arraycopy", "(", "file", ",", "offset", ",", "ret", ",", "0", ",", "length", ")", ";", "return", "ret", ";", "}" ]

[ "Return", "a", "copy", "of", "the", "internal", "array" ]

[ "private", "BufferedImage", "getFontImage", "(", "char", "ch", ")", "{", "// Create a temporary image to extract the character's size\r", "BufferedImage", "tempfontImage", "=", "new", "BufferedImage", "(", "1", ",", "1", ",", "BufferedImage", ".", "TYPE_INT_ARGB", ")", ";", "Graphics2D", "g", "=", "(", "Graphics2D", ")", "tempfontImage", ".", "getGraphics", "(", ")", ";", "if", "(", "antiAlias", "==", "true", ")", "{", "g", ".", "setRenderingHint", "(", "RenderingHints", ".", "KEY_ANTIALIASING", ",", "RenderingHints", ".", "VALUE_ANTIALIAS_ON", ")", ";", "}", "g", ".", "setFont", "(", "font", ")", ";", "fontMetrics", "=", "g", ".", "getFontMetrics", "(", ")", ";", "int", "charwidth", "=", "fontMetrics", ".", "charWidth", "(", "ch", ")", ";", "if", "(", "charwidth", "<=", "0", ")", "{", "charwidth", "=", "1", ";", "}", "int", "charheight", "=", "fontMetrics", ".", "getHeight", "(", ")", ";", "if", "(", "charheight", "<=", "0", ")", "{", "charheight", "=", "fontSize", ";", "}", "// Create another image holding the character we are creating\r", "BufferedImage", "fontImage", ";", "fontImage", "=", "new", "BufferedImage", "(", "charwidth", ",", "charheight", ",", "BufferedImage", ".", "TYPE_INT_ARGB", ")", ";", "Graphics2D", "gt", "=", "(", "Graphics2D", ")", "fontImage", ".", "getGraphics", "(", ")", ";", "if", "(", "antiAlias", "==", "true", ")", "{", "gt", ".", "setRenderingHint", "(", "RenderingHints", ".", "KEY_ANTIALIASING", ",", "RenderingHints", ".", "VALUE_ANTIALIAS_ON", ")", ";", "}", "gt", ".", "setFont", "(", "font", ")", ";", "gt", ".", "setColor", "(", "Color", ".", "WHITE", ")", ";", "int", "charx", "=", "0", ";", "int", "chary", "=", "0", ";", "gt", ".", "drawString", "(", "String", ".", "valueOf", "(", "ch", ")", ",", "(", "charx", ")", ",", "(", "chary", ")", "+", "fontMetrics", ".", "getAscent", "(", ")", ")", ";", "return", "fontImage", ";", "}" ]

[ "Create", "a", "standard", "Java2D", "BufferedImage", "of", "the", "given", "character" ]

[ "private", "void", "createSet", "(", "char", "[", "]", "customCharsArray", ")", "{", "// If there are custom chars then I expand the font texture twice\t\t\r", "if", "(", "customCharsArray", "!=", "null", "&&", "customCharsArray", ".", "length", ">", "0", ")", "{", "textureWidth", "*=", "2", ";", "}", "// In any case this should be done in other way. Texture with size 512x512\r", "// can maintain only 256 characters with resolution of 32x32. The texture\r", "// size should be calculated dynamicaly by looking at character sizes. \r", "try", "{", "BufferedImage", "imgTemp", "=", "new", "BufferedImage", "(", "textureWidth", ",", "textureHeight", ",", "BufferedImage", ".", "TYPE_INT_ARGB", ")", ";", "Graphics2D", "g", "=", "(", "Graphics2D", ")", "imgTemp", ".", "getGraphics", "(", ")", ";", "g", ".", "setColor", "(", "new", "Color", "(", "255", ",", "255", ",", "255", ",", "1", ")", ")", ";", "g", ".", "fillRect", "(", "0", ",", "0", ",", "textureWidth", ",", "textureHeight", ")", ";", "int", "rowHeight", "=", "0", ";", "int", "positionX", "=", "0", ";", "int", "positionY", "=", "0", ";", "int", "customCharsLength", "=", "(", "customCharsArray", "!=", "null", ")", "?", "customCharsArray", ".", "length", ":", "0", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "256", "+", "customCharsLength", ";", "i", "++", ")", "{", "// get 0-255 characters and then custom characters\r", "char", "ch", "=", "(", "i", "<", "256", ")", "?", "(", "char", ")", "i", ":", "customCharsArray", "[", "i", "-", "256", "]", ";", "BufferedImage", "fontImage", "=", "getFontImage", "(", "ch", ")", ";", "IntObject", "newIntObject", "=", "new", "IntObject", "(", ")", ";", "newIntObject", ".", "width", "=", "fontImage", ".", "getWidth", "(", ")", ";", "newIntObject", ".", "height", "=", "fontImage", ".", "getHeight", "(", ")", ";", "if", "(", "positionX", "+", "newIntObject", ".", "width", ">=", "textureWidth", ")", "{", "positionX", "=", "0", ";", "positionY", "+=", "rowHeight", ";", "rowHeight", "=", "0", ";", "}", "newIntObject", ".", "storedX", "=", "positionX", ";", "newIntObject", ".", "storedY", "=", "positionY", ";", "if", "(", "newIntObject", ".", "height", ">", "fontHeight", ")", "{", "fontHeight", "=", "newIntObject", ".", "height", ";", "}", "if", "(", "newIntObject", ".", "height", ">", "rowHeight", ")", "{", "rowHeight", "=", "newIntObject", ".", "height", ";", "}", "// Draw it here\r", "g", ".", "drawImage", "(", "fontImage", ",", "positionX", ",", "positionY", ",", "null", ")", ";", "positionX", "+=", "newIntObject", ".", "width", ";", "if", "(", "i", "<", "256", ")", "{", "// standard characters\r", "charArray", "[", "i", "]", "=", "newIntObject", ";", "}", "else", "{", "// custom characters\r", "customChars", ".", "put", "(", "new", "Character", "(", "ch", ")", ",", "newIntObject", ")", ";", "}", "fontImage", "=", "null", ";", "}", "fontTexture", "=", "BufferedImageUtil", ".", "getTexture", "(", "font", ".", "toString", "(", ")", ",", "imgTemp", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "System", ".", "err", ".", "println", "(", "\"Failed to create font.\"", ")", ";", "e", ".", "printStackTrace", "(", ")", ";", "}", "}" ]

[ "Create", "and", "store", "the", "font" ]

[ "public", "int", "getWidth", "(", "String", "whatchars", ")", "{", "int", "totalwidth", "=", "0", ";", "IntObject", "intObject", "=", "null", ";", "int", "currentChar", "=", "0", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "whatchars", ".", "length", "(", ")", ";", "i", "++", ")", "{", "currentChar", "=", "whatchars", ".", "charAt", "(", "i", ")", ";", "if", "(", "currentChar", "<", "256", ")", "{", "intObject", "=", "charArray", "[", "currentChar", "]", ";", "}", "else", "{", "intObject", "=", "(", "IntObject", ")", "customChars", ".", "get", "(", "new", "Character", "(", "(", "char", ")", "currentChar", ")", ")", ";", "}", "if", "(", "intObject", "!=", "null", ")", "totalwidth", "+=", "intObject", ".", "width", ";", "}", "return", "totalwidth", ";", "}" ]

[ "Get", "the", "width", "of", "a", "given", "String" ]

[ "public", "Cursor", "getCursor", "(", "String", "ref", ",", "int", "x", ",", "int", "y", ")", "throws", "IOException", ",", "LWJGLException", "{", "LoadableImageData", "imageData", "=", "null", ";", "imageData", "=", "ImageDataFactory", ".", "getImageDataFor", "(", "ref", ")", ";", "imageData", ".", "configureEdging", "(", "false", ")", ";", "ByteBuffer", "buf", "=", "imageData", ".", "loadImage", "(", "ResourceLoader", ".", "getResourceAsStream", "(", "ref", ")", ",", "true", ",", "true", ",", "null", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "buf", ".", "limit", "(", ")", ";", "i", "+=", "4", ")", "{", "byte", "red", "=", "buf", ".", "get", "(", "i", ")", ";", "byte", "green", "=", "buf", ".", "get", "(", "i", "+", "1", ")", ";", "byte", "blue", "=", "buf", ".", "get", "(", "i", "+", "2", ")", ";", "byte", "alpha", "=", "buf", ".", "get", "(", "i", "+", "3", ")", ";", "buf", ".", "put", "(", "i", "+", "2", ",", "red", ")", ";", "buf", ".", "put", "(", "i", "+", "1", ",", "green", ")", ";", "buf", ".", "put", "(", "i", ",", "blue", ")", ";", "buf", ".", "put", "(", "i", "+", "3", ",", "alpha", ")", ";", "}", "try", "{", "int", "yspot", "=", "imageData", ".", "getHeight", "(", ")", "-", "y", "-", "1", ";", "if", "(", "yspot", "<", "0", ")", "{", "yspot", "=", "0", ";", "}", "return", "new", "Cursor", "(", "imageData", ".", "getTexWidth", "(", ")", ",", "imageData", ".", "getTexHeight", "(", ")", ",", "x", ",", "yspot", ",", "1", ",", "buf", ".", "asIntBuffer", "(", ")", ",", "null", ")", ";", "}", "catch", "(", "Throwable", "e", ")", "{", "Log", ".", "info", "(", "\"Chances are you cursor is too small for this platform\"", ")", ";", "throw", "new", "LWJGLException", "(", "e", ")", ";", "}", "}" ]

[ "Get", "a", "cursor", "based", "on", "a", "image", "reference", "on", "the", "classpath" ]

[ "private", "int", "getSourcePixel", "(", "int", "x", ",", "int", "y", ")", "{", "x", "=", "Math", ".", "max", "(", "0", ",", "x", ")", ";", "x", "=", "Math", ".", "min", "(", "width", "-", "1", ",", "x", ")", ";", "y", "=", "Math", ".", "max", "(", "0", ",", "y", ")", ";", "y", "=", "Math", ".", "min", "(", "height", "-", "1", ",", "y", ")", ";", "return", "srcImage", "[", "x", "+", "(", "y", "*", "width", ")", "]", ";", "}" ]

[ "Get", "a", "pixel", "from", "the", "source", "image", ".", "This", "handles", "bonds", "checks", "and", "resolves", "to", "edge", "pixels" ]

[ "public", "int", "[", "]", "getScaledData", "(", ")", "{", "for", "(", "int", "x", "=", "0", ";", "x", "<", "width", ";", "x", "++", ")", "{", "for", "(", "int", "y", "=", "0", ";", "y", "<", "height", ";", "y", "++", ")", "{", "process", "(", "x", ",", "y", ")", ";", "}", "}", "return", "dstImage", ";", "}" ]

[ "Get", "the", "scale", "image", "data", ".", "Note", "this", "is", "the", "method", "that", "does", "the", "work", "so", "it", "might", "take", "some", "time", "to", "process", "." ]

[ "private", "void", "updateRender", "(", ")", "{", "if", "(", "inherit", ".", "isSelected", "(", ")", ")", "{", "emitter", ".", "usePoints", "=", "Particle", ".", "INHERIT_POINTS", ";", "oriented", ".", "setEnabled", "(", "true", ")", ";", "}", "if", "(", "quads", ".", "isSelected", "(", ")", ")", "{", "emitter", ".", "usePoints", "=", "Particle", ".", "USE_QUADS", ";", "oriented", ".", "setEnabled", "(", "true", ")", ";", "}", "if", "(", "points", ".", "isSelected", "(", ")", ")", "{", "emitter", ".", "usePoints", "=", "Particle", ".", "USE_POINTS", ";", "oriented", ".", "setEnabled", "(", "false", ")", ";", "oriented", ".", "setSelected", "(", "false", ")", ";", "}", "// oriented\r", "if", "(", "oriented", ".", "isSelected", "(", ")", ")", "emitter", ".", "useOriented", "=", "true", ";", "else", "emitter", ".", "useOriented", "=", "false", ";", "// additive blending\r", "if", "(", "additive", ".", "isSelected", "(", ")", ")", "emitter", ".", "useAdditive", "=", "true", ";", "else", "emitter", ".", "useAdditive", "=", "false", ";", "}" ]

[ "Update", "the", "render", "setting" ]

[ "private", "void", "updateColors", "(", ")", "{", "if", "(", "blockUpdates", ")", "{", "return", ";", "}", "emitter", ".", "colors", ".", "clear", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "grad", ".", "getControlPointCount", "(", ")", ";", "i", "++", ")", "{", "float", "pos", "=", "grad", ".", "getPointPos", "(", "i", ")", ";", "java", ".", "awt", ".", "Color", "col", "=", "grad", ".", "getColor", "(", "i", ")", ";", "Color", "slick", "=", "new", "Color", "(", "col", ".", "getRed", "(", ")", "/", "255.0f", ",", "col", ".", "getGreen", "(", ")", "/", "255.0f", ",", "col", ".", "getBlue", "(", ")", "/", "255.0f", ",", "1.0f", ")", ";", "emitter", ".", "addColorPoint", "(", "pos", ",", "slick", ")", ";", "}", "}" ]

[ "Update", "the", "state", "of", "the", "emitter", "based", "on", "colours", "in", "the", "editor" ]

[ "private", "void", "completeCheck", "(", ")", "throws", "SlickException", "{", "int", "framebuffer", "=", "EXTFramebufferObject", ".", "glCheckFramebufferStatusEXT", "(", "EXTFramebufferObject", ".", "GL_FRAMEBUFFER_EXT", ")", ";", "switch", "(", "framebuffer", ")", "{", "case", "EXTFramebufferObject", ".", "GL_FRAMEBUFFER_COMPLETE_EXT", ":", "break", ";", "case", "EXTFramebufferObject", ".", "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT", ":", "throw", "new", "SlickException", "(", "\"FrameBuffer: \"", "+", "FBO", "+", "\", has caused a GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT exception\"", ")", ";", "case", "EXTFramebufferObject", ".", "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT", ":", "throw", "new", "SlickException", "(", "\"FrameBuffer: \"", "+", "FBO", "+", "\", has caused a GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT exception\"", ")", ";", "case", "EXTFramebufferObject", ".", "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT", ":", "throw", "new", "SlickException", "(", "\"FrameBuffer: \"", "+", "FBO", "+", "\", has caused a GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT exception\"", ")", ";", "case", "EXTFramebufferObject", ".", "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT", ":", "throw", "new", "SlickException", "(", "\"FrameBuffer: \"", "+", "FBO", "+", "\", has caused a GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT exception\"", ")", ";", "case", "EXTFramebufferObject", ".", "GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT", ":", "throw", "new", "SlickException", "(", "\"FrameBuffer: \"", "+", "FBO", "+", "\", has caused a GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT exception\"", ")", ";", "case", "EXTFramebufferObject", ".", "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT", ":", "throw", "new", "SlickException", "(", "\"FrameBuffer: \"", "+", "FBO", "+", "\", has caused a GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT exception\"", ")", ";", "default", ":", "throw", "new", "SlickException", "(", "\"Unexpected reply from glCheckFramebufferStatusEXT: \"", "+", "framebuffer", ")", ";", "}", "}" ]

[ "Check", "the", "FBO", "for", "completeness", "as", "shown", "in", "the", "LWJGL", "tutorial" ]

[ "private", "void", "init", "(", ")", "throws", "SlickException", "{", "IntBuffer", "buffer", "=", "BufferUtils", ".", "createIntBuffer", "(", "1", ")", ";", "EXTFramebufferObject", ".", "glGenFramebuffersEXT", "(", "buffer", ")", ";", "FBO", "=", "buffer", ".", "get", "(", ")", ";", "// for some reason FBOs won't work on textures unless you've absolutely just\r", "// created them.\r", "try", "{", "Texture", "tex", "=", "InternalTextureLoader", ".", "get", "(", ")", ".", "createTexture", "(", "image", ".", "getWidth", "(", ")", ",", "image", ".", "getHeight", "(", ")", ",", "image", ".", "getFilter", "(", ")", ")", ";", "EXTFramebufferObject", ".", "glBindFramebufferEXT", "(", "EXTFramebufferObject", ".", "GL_FRAMEBUFFER_EXT", ",", "FBO", ")", ";", "EXTFramebufferObject", ".", "glFramebufferTexture2DEXT", "(", "EXTFramebufferObject", ".", "GL_FRAMEBUFFER_EXT", ",", "EXTFramebufferObject", ".", "GL_COLOR_ATTACHMENT0_EXT", ",", "GL11", ".", "GL_TEXTURE_2D", ",", "tex", ".", "getTextureID", "(", ")", ",", "0", ")", ";", "completeCheck", "(", ")", ";", "unbind", "(", ")", ";", "// Clear our destination area before using it\r", "clear", "(", ")", ";", "flush", "(", ")", ";", "// keep hold of the original content\r", "drawImage", "(", "image", ",", "0", ",", "0", ")", ";", "image", ".", "setTexture", "(", "tex", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "throw", "new", "SlickException", "(", "\"Failed to create new texture for FBO\"", ")", ";", "}", "}" ]

[ "Initialise", "the", "FBO", "that", "will", "be", "used", "to", "render", "to" ]

[ "private", "void", "bind", "(", ")", "{", "EXTFramebufferObject", ".", "glBindFramebufferEXT", "(", "EXTFramebufferObject", ".", "GL_FRAMEBUFFER_EXT", ",", "FBO", ")", ";", "GL11", ".", "glReadBuffer", "(", "EXTFramebufferObject", ".", "GL_COLOR_ATTACHMENT0_EXT", ")", ";", "}" ]

[ "Bind", "to", "the", "FBO", "created" ]

[ "protected", "void", "enterOrtho", "(", ")", "{", "GL11", ".", "glMatrixMode", "(", "GL11", ".", "GL_PROJECTION", ")", ";", "GL11", ".", "glLoadIdentity", "(", ")", ";", "GL11", ".", "glOrtho", "(", "0", ",", "screenWidth", ",", "0", ",", "screenHeight", ",", "1", ",", "-", "1", ")", ";", "GL11", ".", "glMatrixMode", "(", "GL11", ".", "GL_MODELVIEW", ")", ";", "}" ]

[ "Enter", "the", "orthographic", "mode" ]

[ "public", "void", "error", "(", "Throwable", "e", ")", "{", "out", ".", "println", "(", "new", "Date", "(", ")", "+", "\" ERROR:\"", "+", "e", ".", "getMessage", "(", ")", ")", ";", "e", ".", "printStackTrace", "(", "out", ")", ";", "}" ]

[ "Log", "an", "error" ]

[ "public", "void", "warn", "(", "String", "message", ",", "Throwable", "e", ")", "{", "warn", "(", "message", ")", ";", "e", ".", "printStackTrace", "(", "out", ")", ";", "}" ]

[ "Log", "a", "warning", "with", "an", "exception", "that", "caused", "it" ]

[ "private", "static", "void", "init", "(", ")", "throws", "SlickException", "{", "init", "=", "true", ";", "if", "(", "fbo", ")", "{", "fbo", "=", "GLContext", ".", "getCapabilities", "(", ")", ".", "GL_EXT_framebuffer_object", ";", "}", "pbuffer", "=", "(", "Pbuffer", ".", "getCapabilities", "(", ")", "&", "Pbuffer", ".", "PBUFFER_SUPPORTED", ")", "!=", "0", ";", "pbufferRT", "=", "(", "Pbuffer", ".", "getCapabilities", "(", ")", "&", "Pbuffer", ".", "RENDER_TEXTURE_SUPPORTED", ")", "!=", "0", ";", "if", "(", "!", "fbo", "&&", "!", "pbuffer", "&&", "!", "pbufferRT", ")", "{", "throw", "new", "SlickException", "(", "\"Your OpenGL card does not support offscreen buffers and hence can't handle the dynamic images required for this application.\"", ")", ";", "}", "Log", ".", "info", "(", "\"Offscreen Buffers FBO=\"", "+", "fbo", "+", "\" PBUFFER=\"", "+", "pbuffer", "+", "\" PBUFFERRT=\"", "+", "pbufferRT", ")", ";", "}" ]

[ "Initialise", "offscreen", "rendering", "by", "checking", "what", "buffers", "are", "supported", "by", "the", "card" ]

[ "public", "static", "Graphics", "getGraphicsForImage", "(", "Image", "image", ")", "throws", "SlickException", "{", "Graphics", "g", "=", "(", "Graphics", ")", "graphics", ".", "get", "(", "image", ".", "getTexture", "(", ")", ")", ";", "if", "(", "g", "==", "null", ")", "{", "g", "=", "createGraphics", "(", "image", ")", ";", "graphics", ".", "put", "(", "image", ".", "getTexture", "(", ")", ",", "g", ")", ";", "}", "return", "g", ";", "}" ]

[ "Get", "a", "graphics", "context", "for", "a", "particular", "image" ]

[ "public", "static", "void", "releaseGraphicsForImage", "(", "Image", "image", ")", "throws", "SlickException", "{", "Graphics", "g", "=", "(", "Graphics", ")", "graphics", ".", "remove", "(", "image", ".", "getTexture", "(", ")", ")", ";", "if", "(", "g", "!=", "null", ")", "{", "g", ".", "destroy", "(", ")", ";", "}", "}" ]

[ "Release", "any", "graphics", "context", "that", "is", "assocaited", "with", "the", "given", "image" ]

[ "private", "static", "Graphics", "createGraphics", "(", "Image", "image", ")", "throws", "SlickException", "{", "init", "(", ")", ";", "if", "(", "fbo", ")", "{", "try", "{", "return", "new", "FBOGraphics", "(", "image", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "fbo", "=", "false", ";", "Log", ".", "warn", "(", "\"FBO failed in use, falling back to PBuffer\"", ")", ";", "}", "}", "if", "(", "pbuffer", ")", "{", "if", "(", "pbufferRT", ")", "{", "return", "new", "PBufferGraphics", "(", "image", ")", ";", "}", "else", "{", "return", "new", "PBufferUniqueGraphics", "(", "image", ")", ";", "}", "}", "throw", "new", "SlickException", "(", "\"Failed to create offscreen buffer even though the card reports it's possible\"", ")", ";", "}" ]

[ "Create", "an", "underlying", "graphics", "context", "for", "the", "given", "image" ]

[ "protected", "boolean", "isValidLocation", "(", "Mover", "mover", ",", "int", "sx", ",", "int", "sy", ",", "int", "x", ",", "int", "y", ")", "{", "boolean", "invalid", "=", "(", "x", "<", "0", ")", "||", "(", "y", "<", "0", ")", "||", "(", "x", ">=", "map", ".", "getWidthInTiles", "(", ")", ")", "||", "(", "y", ">=", "map", ".", "getHeightInTiles", "(", ")", ")", ";", "if", "(", "(", "!", "invalid", ")", "&&", "(", "(", "sx", "!=", "x", ")", "||", "(", "sy", "!=", "y", ")", ")", ")", "{", "this", ".", "mover", "=", "mover", ";", "this", ".", "sourceX", "=", "sx", ";", "this", ".", "sourceY", "=", "sy", ";", "invalid", "=", "map", ".", "blocked", "(", "this", ",", "x", ",", "y", ")", ";", "}", "return", "!", "invalid", ";", "}" ]

[ "Check", "if", "a", "given", "location", "is", "valid", "for", "the", "supplied", "mover" ]

[ "public", "float", "getMovementCost", "(", "Mover", "mover", ",", "int", "sx", ",", "int", "sy", ",", "int", "tx", ",", "int", "ty", ")", "{", "this", ".", "mover", "=", "mover", ";", "this", ".", "sourceX", "=", "sx", ";", "this", ".", "sourceY", "=", "sy", ";", "return", "map", ".", "getCost", "(", "this", ",", "tx", ",", "ty", ")", ";", "}" ]

[ "Get", "the", "cost", "to", "move", "through", "a", "given", "location" ]

[ "public", "Color", "darker", "(", "float", "scale", ")", "{", "scale", "=", "1", "-", "scale", ";", "Color", "temp", "=", "new", "Color", "(", "r", "*", "scale", ",", "g", "*", "scale", ",", "b", "*", "scale", ",", "a", ")", ";", "return", "temp", ";", "}" ]

[ "Make", "a", "darker", "instance", "of", "this", "colour" ]

[ "public", "Color", "brighter", "(", "float", "scale", ")", "{", "scale", "+=", "1", ";", "Color", "temp", "=", "new", "Color", "(", "r", "*", "scale", ",", "g", "*", "scale", ",", "b", "*", "scale", ",", "a", ")", ";", "return", "temp", ";", "}" ]

[ "Make", "a", "brighter", "instance", "of", "this", "colour" ]

[ "public", "Color", "multiply", "(", "Color", "c", ")", "{", "return", "new", "Color", "(", "r", "*", "c", ".", "r", ",", "g", "*", "c", ".", "g", ",", "b", "*", "c", ".", "b", ",", "a", "*", "c", ".", "a", ")", ";", "}" ]

[ "Multiply", "this", "color", "by", "another" ]

[ "protected", "void", "notifyListeners", "(", ")", "{", "Iterator", "it", "=", "listeners", ".", "iterator", "(", ")", ";", "while", "(", "it", ".", "hasNext", "(", ")", ")", "{", "(", "(", "ComponentListener", ")", "it", ".", "next", "(", ")", ")", ".", "componentActivated", "(", "this", ")", ";", "}", "}" ]

[ "Notify", "all", "the", "listeners", "." ]

[ "public", "void", "setFocus", "(", "boolean", "focus", ")", "{", "if", "(", "focus", ")", "{", "if", "(", "currentFocus", "!=", "null", ")", "{", "currentFocus", ".", "setFocus", "(", "false", ")", ";", "}", "currentFocus", "=", "this", ";", "}", "else", "{", "if", "(", "currentFocus", "==", "this", ")", "{", "currentFocus", "=", "null", ";", "}", "}", "this", ".", "focus", "=", "focus", ";", "}" ]

[ "Indicate", "whether", "this", "component", "should", "be", "focused", "or", "not" ]

[ "public", "void", "mouseReleased", "(", "int", "button", ",", "int", "x", ",", "int", "y", ")", "{", "setFocus", "(", "Rectangle", ".", "contains", "(", "x", ",", "y", ",", "getX", "(", ")", ",", "getY", "(", ")", ",", "getWidth", "(", ")", ",", "getHeight", "(", ")", ")", ")", ";", "}" ]

[ "Gives", "the", "focus", "to", "this", "component", "with", "a", "click", "of", "the", "mouse", "." ]

[ "public", "void", "setMusicOn", "(", "boolean", "music", ")", "{", "if", "(", "soundWorks", ")", "{", "this", ".", "music", "=", "music", ";", "if", "(", "music", ")", "{", "restartLoop", "(", ")", ";", "setMusicVolume", "(", "musicVolume", ")", ";", "}", "else", "{", "pauseLoop", "(", ")", ";", "}", "}", "}" ]

[ "Inidicate", "whether", "music", "should", "be", "playing" ]

[ "public", "void", "setCurrentMusicVolume", "(", "float", "volume", ")", "{", "if", "(", "volume", "<", "0", ")", "{", "volume", "=", "0", ";", "}", "if", "(", "volume", ">", "1", ")", "{", "volume", "=", "1", ";", "}", "if", "(", "soundWorks", ")", "{", "lastCurrentMusicVolume", "=", "volume", ";", "AL10", ".", "alSourcef", "(", "sources", ".", "get", "(", "0", ")", ",", "AL10", ".", "AL_GAIN", ",", "lastCurrentMusicVolume", "*", "musicVolume", ")", ";", "}", "}" ]

[ "Set", "the", "music", "volume", "of", "the", "current", "playing", "music", ".", "Does", "NOT", "affect", "the", "global", "volume" ]

[ "public", "void", "init", "(", ")", "{", "if", "(", "inited", ")", "{", "return", ";", "}", "Log", ".", "info", "(", "\"Initialising sounds..\"", ")", ";", "inited", "=", "true", ";", "AccessController", ".", "doPrivileged", "(", "new", "PrivilegedAction", "(", ")", "{", "public", "Object", "run", "(", ")", "{", "try", "{", "AL", ".", "create", "(", ")", ";", "soundWorks", "=", "true", ";", "sounds", "=", "true", ";", "music", "=", "true", ";", "Log", ".", "info", "(", "\"- Sound works\"", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "Log", ".", "error", "(", "\"Sound initialisation failure.\"", ")", ";", "Log", ".", "error", "(", "e", ")", ";", "soundWorks", "=", "false", ";", "sounds", "=", "false", ";", "music", "=", "false", ";", "}", "return", "null", ";", "}", "}", ")", ";", "if", "(", "soundWorks", ")", "{", "sourceCount", "=", "0", ";", "sources", "=", "BufferUtils", ".", "createIntBuffer", "(", "maxSources", ")", ";", "while", "(", "AL10", ".", "alGetError", "(", ")", "==", "AL10", ".", "AL_NO_ERROR", ")", "{", "IntBuffer", "temp", "=", "BufferUtils", ".", "createIntBuffer", "(", "1", ")", ";", "try", "{", "AL10", ".", "alGenSources", "(", "temp", ")", ";", "if", "(", "AL10", ".", "alGetError", "(", ")", "==", "AL10", ".", "AL_NO_ERROR", ")", "{", "sourceCount", "++", ";", "sources", ".", "put", "(", "temp", ".", "get", "(", "0", ")", ")", ";", "if", "(", "sourceCount", ">", "maxSources", "-", "1", ")", "{", "break", ";", "}", "}", "}", "catch", "(", "OpenALException", "e", ")", "{", "// expected at the end\r", "break", ";", "}", "}", "Log", ".", "info", "(", "\"- \"", "+", "sourceCount", "+", "\" OpenAL source available\"", ")", ";", "if", "(", "AL10", ".", "alGetError", "(", ")", "!=", "AL10", ".", "AL_NO_ERROR", ")", "{", "sounds", "=", "false", ";", "music", "=", "false", ";", "soundWorks", "=", "false", ";", "Log", ".", "error", "(", "\"- AL init failed\"", ")", ";", "}", "else", "{", "FloatBuffer", "listenerOri", "=", "BufferUtils", ".", "createFloatBuffer", "(", "6", ")", ".", "put", "(", "new", "float", "[", "]", "{", "0.0f", ",", "0.0f", ",", "-", "1.0f", ",", "0.0f", ",", "1.0f", ",", "0.0f", "}", ")", ";", "FloatBuffer", "listenerVel", "=", "BufferUtils", ".", "createFloatBuffer", "(", "3", ")", ".", "put", "(", "new", "float", "[", "]", "{", "0.0f", ",", "0.0f", ",", "0.0f", "}", ")", ";", "FloatBuffer", "listenerPos", "=", "BufferUtils", ".", "createFloatBuffer", "(", "3", ")", ".", "put", "(", "new", "float", "[", "]", "{", "0.0f", ",", "0.0f", ",", "0.0f", "}", ")", ";", "listenerPos", ".", "flip", "(", ")", ";", "listenerVel", ".", "flip", "(", ")", ";", "listenerOri", ".", "flip", "(", ")", ";", "AL10", ".", "alListener", "(", "AL10", ".", "AL_POSITION", ",", "listenerPos", ")", ";", "AL10", ".", "alListener", "(", "AL10", ".", "AL_VELOCITY", ",", "listenerVel", ")", ";", "AL10", ".", "alListener", "(", "AL10", ".", "AL_ORIENTATION", ",", "listenerOri", ")", ";", "Log", ".", "info", "(", "\"- Sounds source generated\"", ")", ";", "}", "}", "}" ]

[ "Initialise", "the", "sound", "effects", "stored", ".", "This", "must", "be", "called", "before", "anything", "else", "will", "work" ]

[ "boolean", "isPlaying", "(", "int", "index", ")", "{", "int", "state", "=", "AL10", ".", "alGetSourcei", "(", "sources", ".", "get", "(", "index", ")", ",", "AL10", ".", "AL_SOURCE_STATE", ")", ";", "return", "(", "state", "==", "AL10", ".", "AL_PLAYING", ")", ";", "}" ]

[ "Check", "if", "a", "particular", "source", "is", "playing" ]

[ "private", "int", "findFreeSource", "(", ")", "{", "for", "(", "int", "i", "=", "1", ";", "i", "<", "sourceCount", "-", "1", ";", "i", "++", ")", "{", "int", "state", "=", "AL10", ".", "alGetSourcei", "(", "sources", ".", "get", "(", "i", ")", ",", "AL10", ".", "AL_SOURCE_STATE", ")", ";", "if", "(", "(", "state", "!=", "AL10", ".", "AL_PLAYING", ")", "&&", "(", "state", "!=", "AL10", ".", "AL_PAUSED", ")", ")", "{", "return", "i", ";", "}", "}", "return", "-", "1", ";", "}" ]

[ "Find", "a", "free", "sound", "source" ]

[ "public", "void", "setMusicPitch", "(", "float", "pitch", ")", "{", "if", "(", "soundWorks", ")", "{", "AL10", ".", "alSourcef", "(", "sources", ".", "get", "(", "0", ")", ",", "AL10", ".", "AL_PITCH", ",", "pitch", ")", ";", "}", "}" ]

[ "Set", "the", "pitch", "at", "which", "the", "current", "music", "is", "being", "played" ]

[ "public", "Audio", "getWAV", "(", "String", "ref", ")", "throws", "IOException", "{", "return", "getWAV", "(", "ref", ",", "ResourceLoader", ".", "getResourceAsStream", "(", "ref", ")", ")", ";", "}" ]

[ "Get", "the", "Sound", "based", "on", "a", "specified", "WAV", "file" ]

[ "void", "setMOD", "(", "MODSound", "sound", ")", "{", "if", "(", "!", "soundWorks", ")", "{", "return", ";", "}", "currentMusic", "=", "sources", ".", "get", "(", "0", ")", ";", "stopSource", "(", "0", ")", ";", "this", ".", "mod", "=", "sound", ";", "if", "(", "sound", "!=", "null", ")", "{", "this", ".", "stream", "=", "null", ";", "}", "paused", "=", "false", ";", "}" ]

[ "Set", "the", "mod", "thats", "being", "streamed", "if", "any" ]

[ "void", "setStream", "(", "OpenALStreamPlayer", "stream", ")", "{", "if", "(", "!", "soundWorks", ")", "{", "return", ";", "}", "currentMusic", "=", "sources", ".", "get", "(", "0", ")", ";", "this", ".", "stream", "=", "stream", ";", "if", "(", "stream", "!=", "null", ")", "{", "this", ".", "mod", "=", "null", ";", "}", "paused", "=", "false", ";", "}" ]

[ "Set", "the", "stream", "being", "played" ]

[ "public", "void", "poll", "(", "int", "delta", ")", "{", "if", "(", "!", "soundWorks", ")", "{", "return", ";", "}", "if", "(", "paused", ")", "{", "return", ";", "}", "if", "(", "music", ")", "{", "if", "(", "mod", "!=", "null", ")", "{", "try", "{", "mod", ".", "poll", "(", ")", ";", "}", "catch", "(", "OpenALException", "e", ")", "{", "Log", ".", "error", "(", "\"Error with OpenGL MOD Player on this this platform\"", ")", ";", "Log", ".", "error", "(", "e", ")", ";", "mod", "=", "null", ";", "}", "}", "if", "(", "stream", "!=", "null", ")", "{", "try", "{", "stream", ".", "update", "(", ")", ";", "}", "catch", "(", "OpenALException", "e", ")", "{", "Log", ".", "error", "(", "\"Error with OpenGL Streaming Player on this this platform\"", ")", ";", "Log", ".", "error", "(", "e", ")", ";", "mod", "=", "null", ";", "}", "}", "}", "}" ]

[ "Poll", "the", "streaming", "system" ]

[ "public", "boolean", "isMusicPlaying", "(", ")", "{", "if", "(", "!", "soundWorks", ")", "{", "return", "false", ";", "}", "int", "state", "=", "AL10", ".", "alGetSourcei", "(", "sources", ".", "get", "(", "0", ")", ",", "AL10", ".", "AL_SOURCE_STATE", ")", ";", "return", "(", "(", "state", "==", "AL10", ".", "AL_PLAYING", ")", "||", "(", "state", "==", "AL10", ".", "AL_PAUSED", ")", ")", ";", "}" ]

[ "Check", "if", "the", "music", "is", "currently", "playing" ]

[ "protected", "void", "addValue", "(", "String", "name", ",", "ValuePanel", "valuePanel", ")", "{", "named", ".", "put", "(", "name", ",", "valuePanel", ")", ";", "valuePanel", ".", "setBounds", "(", "0", ",", "10", "+", "yPos", ",", "280", ",", "63", ")", ";", "valuePanel", ".", "addListener", "(", "this", ")", ";", "add", "(", "valuePanel", ")", ";", "yPos", "+=", "63", ";", "}" ]

[ "Add", "a", "configurable", "value", "to", "the", "mapping", "table" ]

[ "protected", "void", "addMinMax", "(", "String", "name", ",", "MinMaxPanel", "minMax", ")", "{", "named", ".", "put", "(", "name", ",", "minMax", ")", ";", "minMax", ".", "setBounds", "(", "0", ",", "10", "+", "yPos", ",", "280", ",", "minMax", ".", "getOffset", "(", ")", ")", ";", "minMax", ".", "addListener", "(", "this", ")", ";", "add", "(", "minMax", ")", ";", "yPos", "+=", "minMax", ".", "getOffset", "(", ")", ";", "}" ]

[ "Add", "a", "configurable", "range", "panel", "to", "the", "mapping", "table" ]

[ "protected", "void", "link", "(", "Range", "range", ",", "String", "name", ")", "{", "link", "(", "range", ",", "(", "MinMaxPanel", ")", "named", ".", "get", "(", "name", ")", ")", ";", "}" ]

[ "Link", "a", "emitter", "configurable", "range", "to", "a", "named", "component" ]

[ "protected", "void", "link", "(", "Value", "value", ",", "String", "name", ")", "{", "link", "(", "value", ",", "(", "ValuePanel", ")", "named", ".", "get", "(", "name", ")", ")", ";", "}" ]

[ "Link", "a", "emitter", "configurable", "value", "to", "a", "named", "component" ]

[ "private", "void", "link", "(", "Value", "value", ",", "ValuePanel", "panel", ")", "{", "controlToData", ".", "put", "(", "panel", ",", "value", ")", ";", "if", "(", "value", "instanceof", "SimpleValue", ")", "panel", ".", "setValue", "(", "(", "int", ")", "(", "(", "SimpleValue", ")", "value", ")", ".", "getValue", "(", "0", ")", ")", ";", "else", "if", "(", "value", "instanceof", "RandomValue", ")", "panel", ".", "setValue", "(", "(", "int", ")", "(", "(", "RandomValue", ")", "value", ")", ".", "getValue", "(", ")", ")", ";", "}" ]

[ "Link", "a", "emitter", "configurable", "value", "to", "a", "value", "panel" ]

[ "private", "void", "link", "(", "Range", "range", ",", "MinMaxPanel", "panel", ")", "{", "controlToData", ".", "put", "(", "panel", ",", "range", ")", ";", "panel", ".", "setMax", "(", "(", "int", ")", "range", ".", "getMax", "(", ")", ")", ";", "panel", ".", "setMin", "(", "(", "int", ")", "range", ".", "getMin", "(", ")", ")", ";", "panel", ".", "setEnabledValue", "(", "range", ".", "isEnabled", "(", ")", ")", ";", "}" ]

[ "Link", "a", "emitter", "configurable", "range", "to", "a", "value", "panel" ]

[ "public", "BufferedImage", "getScaledImage", "(", ")", "{", "RawScale3x", "scaler", "=", "new", "RawScale3x", "(", "srcData", ",", "width", ",", "height", ")", ";", "BufferedImage", "image", "=", "new", "BufferedImage", "(", "width", "*", "3", ",", "height", "*", "3", ",", "BufferedImage", ".", "TYPE_INT_ARGB", ")", ";", "image", ".", "setRGB", "(", "0", ",", "0", ",", "width", "*", "3", ",", "height", "*", "3", ",", "scaler", ".", "getScaledData", "(", ")", ",", "0", ",", "width", "*", "3", ")", ";", "return", "image", ";", "}" ]

[ "Retrieve", "the", "scaled", "image", ".", "Note", "this", "is", "the", "method", "that", "actually", "does", "the", "work", "so", "it", "may", "take", "some", "time", "to", "return" ]

[ "public", "static", "void", "main", "(", "String", "argv", "[", "]", ")", "{", "String", "srcFile", "=", "\"randam_orig.png\"", ";", "try", "{", "System", ".", "out", ".", "println", "(", "\"Reading: \"", "+", "srcFile", ")", ";", "BufferedImage", "src", "=", "ImageIO", ".", "read", "(", "new", "File", "(", "srcFile", ")", ")", ";", "ImageScale3x", "scaler", "=", "new", "ImageScale3x", "(", "src", ")", ";", "BufferedImage", "out", "=", "scaler", ".", "getScaledImage", "(", ")", ";", "String", "outFile", "=", "srcFile", ".", "substring", "(", "0", ",", "srcFile", ".", "length", "(", ")", "-", "4", ")", ";", "outFile", "+=", "\"3x\"", ";", "outFile", "+=", "\".png\"", ";", "System", ".", "out", ".", "println", "(", "\"Writing: \"", "+", "outFile", ")", ";", "ImageIO", ".", "write", "(", "out", ",", "\"PNG\"", ",", "new", "File", "(", "outFile", ")", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "e", ".", "printStackTrace", "(", ")", ";", "}", "}" ]

[ "An", "entry", "point", "and", "a", "bit", "of", "test", "code" ]

[ "private", "static", "float", "findSignedDistance", "(", "final", "int", "pointX", ",", "final", "int", "pointY", ",", "BufferedImage", "inImage", ",", "final", "int", "scanWidth", ",", "final", "int", "scanHeight", ")", "{", "Color", "baseColour", "=", "new", "Color", "(", "inImage", ".", "getRGB", "(", "pointX", ",", "pointY", ")", ")", ";", "final", "boolean", "baseIsSolid", "=", "baseColour", ".", "getRed", "(", ")", ">", "0", ";", "float", "closestDistance", "=", "Float", ".", "MAX_VALUE", ";", "boolean", "closestValid", "=", "false", ";", "final", "int", "startX", "=", "pointX", "-", "(", "scanWidth", "/", "2", ")", ";", "final", "int", "endX", "=", "startX", "+", "scanWidth", ";", "final", "int", "startY", "=", "pointY", "-", "(", "scanHeight", "/", "2", ")", ";", "final", "int", "endY", "=", "startY", "+", "scanHeight", ";", "for", "(", "int", "x", "=", "startX", ";", "x", "<", "endX", ";", "x", "++", ")", "{", "if", "(", "x", "<", "0", "||", "x", ">=", "inImage", ".", "getWidth", "(", ")", ")", "continue", ";", "for", "(", "int", "y", "=", "startY", ";", "y", "<", "endY", ";", "y", "++", ")", "{", "if", "(", "y", "<", "0", "||", "y", ">=", "inImage", ".", "getWidth", "(", ")", ")", "continue", ";", "Color", "c", "=", "new", "Color", "(", "inImage", ".", "getRGB", "(", "x", ",", "y", ")", ")", ";", "if", "(", "baseIsSolid", ")", "{", "if", "(", "c", ".", "getRed", "(", ")", "==", "0", ")", "{", "final", "float", "dist", "=", "separation", "(", "pointX", ",", "pointY", ",", "x", ",", "y", ")", ";", "if", "(", "dist", "<", "closestDistance", ")", "{", "closestDistance", "=", "dist", ";", "closestValid", "=", "true", ";", "}", "}", "}", "else", "{", "if", "(", "c", ".", "getRed", "(", ")", ">", "0", ")", "{", "final", "float", "dist", "=", "separation", "(", "pointX", ",", "pointY", ",", "x", ",", "y", ")", ";", "if", "(", "dist", "<", "closestDistance", ")", "{", "closestDistance", "=", "dist", ";", "closestValid", "=", "true", ";", "}", "}", "}", "}", "}", "if", "(", "baseIsSolid", ")", "{", "if", "(", "closestValid", ")", "return", "closestDistance", ";", "else", "return", "Float", ".", "MAX_VALUE", ";", "}", "else", "{", "if", "(", "closestValid", ")", "return", "-", "closestDistance", ";", "else", "return", "Float", ".", "MIN_VALUE", ";", "}", "}" ]

[ "Find", "the", "signed", "distance", "for", "a", "given", "point" ]

[ "public", "void", "save", "(", "File", "file", ")", "throws", "IOException", "{", "PrintStream", "out", "=", "new", "PrintStream", "(", "new", "FileOutputStream", "(", "file", ")", ")", ";", "out", ".", "println", "(", "\"font.size=\"", "+", "fontSize", ")", ";", "out", ".", "println", "(", "\"font.bold=\"", "+", "bold", ")", ";", "out", ".", "println", "(", "\"font.italic=\"", "+", "italic", ")", ";", "out", ".", "println", "(", ")", ";", "out", ".", "println", "(", "\"pad.top=\"", "+", "paddingTop", ")", ";", "out", ".", "println", "(", "\"pad.right=\"", "+", "paddingRight", ")", ";", "out", ".", "println", "(", "\"pad.bottom=\"", "+", "paddingBottom", ")", ";", "out", ".", "println", "(", "\"pad.left=\"", "+", "paddingLeft", ")", ";", "out", ".", "println", "(", "\"pad.advance.x=\"", "+", "paddingAdvanceX", ")", ";", "out", ".", "println", "(", "\"pad.advance.y=\"", "+", "paddingAdvanceY", ")", ";", "out", ".", "println", "(", ")", ";", "out", ".", "println", "(", "\"glyph.page.width=\"", "+", "glyphPageWidth", ")", ";", "out", ".", "println", "(", "\"glyph.page.height=\"", "+", "glyphPageHeight", ")", ";", "out", ".", "println", "(", ")", ";", "for", "(", "Iterator", "iter", "=", "effects", ".", "iterator", "(", ")", ";", "iter", ".", "hasNext", "(", ")", ";", ")", "{", "ConfigurableEffect", "effect", "=", "(", "ConfigurableEffect", ")", "iter", ".", "next", "(", ")", ";", "out", ".", "println", "(", "\"effect.class=\"", "+", "effect", ".", "getClass", "(", ")", ".", "getName", "(", ")", ")", ";", "for", "(", "Iterator", "iter2", "=", "effect", ".", "getValues", "(", ")", ".", "iterator", "(", ")", ";", "iter2", ".", "hasNext", "(", ")", ";", ")", "{", "Value", "value", "=", "(", "Value", ")", "iter2", ".", "next", "(", ")", ";", "out", ".", "println", "(", "\"effect.\"", "+", "value", ".", "getName", "(", ")", "+", "\"=\"", "+", "value", ".", "getString", "(", ")", ")", ";", "}", "out", ".", "println", "(", ")", ";", "}", "out", ".", "close", "(", ")", ";", "}" ]

[ "Saves", "the", "settings", "to", "a", "file", "." ]

[ "private", "void", "flushBuffer", "(", ")", "{", "if", "(", "vertIndex", "==", "0", ")", "{", "return", ";", "}", "if", "(", "currentType", "==", "NONE", ")", "{", "return", ";", "}", "if", "(", "vertIndex", "<", "TOLERANCE", ")", "{", "GL11", ".", "glBegin", "(", "currentType", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "vertIndex", ";", "i", "++", ")", "{", "GL11", ".", "glColor4f", "(", "cols", "[", "(", "i", "*", "4", ")", "+", "0", "]", ",", "cols", "[", "(", "i", "*", "4", ")", "+", "1", "]", ",", "cols", "[", "(", "i", "*", "4", ")", "+", "2", "]", ",", "cols", "[", "(", "i", "*", "4", ")", "+", "3", "]", ")", ";", "GL11", ".", "glTexCoord2f", "(", "texs", "[", "(", "i", "*", "2", ")", "+", "0", "]", ",", "texs", "[", "(", "i", "*", "2", ")", "+", "1", "]", ")", ";", "GL11", ".", "glVertex3f", "(", "verts", "[", "(", "i", "*", "3", ")", "+", "0", "]", ",", "verts", "[", "(", "i", "*", "3", ")", "+", "1", "]", ",", "verts", "[", "(", "i", "*", "3", ")", "+", "2", "]", ")", ";", "}", "GL11", ".", "glEnd", "(", ")", ";", "currentType", "=", "NONE", ";", "return", ";", "}", "vertices", ".", "clear", "(", ")", ";", "colors", ".", "clear", "(", ")", ";", "textures", ".", "clear", "(", ")", ";", "vertices", ".", "put", "(", "verts", ",", "0", ",", "vertIndex", "*", "3", ")", ";", "colors", ".", "put", "(", "cols", ",", "0", ",", "vertIndex", "*", "4", ")", ";", "textures", ".", "put", "(", "texs", ",", "0", ",", "vertIndex", "*", "2", ")", ";", "vertices", ".", "flip", "(", ")", ";", "colors", ".", "flip", "(", ")", ";", "textures", ".", "flip", "(", ")", ";", "GL11", ".", "glVertexPointer", "(", "3", ",", "0", ",", "vertices", ")", ";", "GL11", ".", "glColorPointer", "(", "4", ",", "0", ",", "colors", ")", ";", "GL11", ".", "glTexCoordPointer", "(", "2", ",", "0", ",", "textures", ")", ";", "GL11", ".", "glDrawArrays", "(", "currentType", ",", "0", ",", "vertIndex", ")", ";", "currentType", "=", "NONE", ";", "}" ]

[ "Flush", "the", "currently", "cached", "data", "down", "to", "the", "card" ]

[ "private", "void", "applyBuffer", "(", ")", "{", "if", "(", "listMode", ">", "0", ")", "{", "return", ";", "}", "if", "(", "vertIndex", "!=", "0", ")", "{", "flushBuffer", "(", ")", ";", "startBuffer", "(", ")", ";", "}", "super", ".", "glColor4f", "(", "color", "[", "0", "]", ",", "color", "[", "1", "]", ",", "color", "[", "2", "]", ",", "color", "[", "3", "]", ")", ";", "}" ]

[ "Apply", "the", "current", "buffer", "and", "restart", "it" ]

[ "private", "boolean", "isSplittable", "(", "int", "count", ",", "int", "type", ")", "{", "switch", "(", "type", ")", "{", "case", "GL11", ".", "GL_QUADS", ":", "return", "count", "%", "4", "==", "0", ";", "case", "GL11", ".", "GL_TRIANGLES", ":", "return", "count", "%", "3", "==", "0", ";", "case", "GL11", ".", "GL_LINE", ":", "return", "count", "%", "2", "==", "0", ";", "}", "return", "false", ";", "}" ]

[ "Check", "if", "the", "geometry", "being", "created", "can", "be", "split", "at", "the", "current", "index" ]

[ "private", "void", "checkTarget", "(", ")", "{", "if", "(", "target", "==", "null", ")", "{", "try", "{", "load", "(", ")", ";", "LoadingList", ".", "get", "(", ")", ".", "remove", "(", "this", ")", ";", "return", ";", "}", "catch", "(", "IOException", "e", ")", "{", "throw", "new", "RuntimeException", "(", "\"Attempt to use deferred texture before loading and resource not found: \"", "+", "resourceName", ")", ";", "}", "}", "}" ]

[ "Check", "if", "the", "target", "has", "been", "obtained", "already" ]

[ "public", "boolean", "contains", "(", "float", "xp", ",", "float", "yp", ")", "{", "checkPoints", "(", ")", ";", "if", "(", "xp", "<=", "getX", "(", ")", ")", "{", "return", "false", ";", "}", "if", "(", "yp", "<=", "getY", "(", ")", ")", "{", "return", "false", ";", "}", "if", "(", "xp", ">=", "maxX", ")", "{", "return", "false", ";", "}", "if", "(", "yp", ">=", "maxY", ")", "{", "return", "false", ";", "}", "return", "true", ";", "}" ]

[ "Check", "if", "this", "rectangle", "contains", "a", "point" ]

[ "public", "void", "setBounds", "(", "Rectangle", "other", ")", "{", "setBounds", "(", "other", ".", "getX", "(", ")", ",", "other", ".", "getY", "(", ")", ",", "other", ".", "getWidth", "(", ")", ",", "other", ".", "getHeight", "(", ")", ")", ";", "}" ]

[ "Set", "the", "bounds", "of", "this", "rectangle", "based", "on", "the", "given", "rectangle" ]

[ "public", "void", "setBounds", "(", "float", "x", ",", "float", "y", ",", "float", "width", ",", "float", "height", ")", "{", "setX", "(", "x", ")", ";", "setY", "(", "y", ")", ";", "setSize", "(", "width", ",", "height", ")", ";", "}" ]

[ "Set", "the", "bounds", "of", "this", "rectangle" ]

[ "public", "void", "grow", "(", "float", "h", ",", "float", "v", ")", "{", "setX", "(", "getX", "(", ")", "-", "h", ")", ";", "setY", "(", "getY", "(", ")", "-", "v", ")", ";", "setWidth", "(", "getWidth", "(", ")", "+", "(", "h", "*", "2", ")", ")", ";", "setHeight", "(", "getHeight", "(", ")", "+", "(", "v", "*", "2", ")", ")", ";", "}" ]

[ "Grow", "the", "rectangle", "at", "all", "edges", "by", "the", "given", "amounts", ".", "This", "will", "result", "in", "the", "rectangle", "getting", "larger", "around", "it", "s", "centre", "." ]

[ "public", "void", "setWidth", "(", "float", "width", ")", "{", "if", "(", "width", "!=", "this", ".", "width", ")", "{", "pointsDirty", "=", "true", ";", "this", ".", "width", "=", "width", ";", "maxX", "=", "x", "+", "width", ";", "}", "}" ]

[ "Set", "the", "width", "of", "this", "box" ]

[ "public", "void", "setHeight", "(", "float", "height", ")", "{", "if", "(", "height", "!=", "this", ".", "height", ")", "{", "pointsDirty", "=", "true", ";", "this", ".", "height", "=", "height", ";", "maxY", "=", "y", "+", "height", ";", "}", "}" ]

[ "Set", "the", "heightof", "this", "box" ]

[ "public", "boolean", "intersects", "(", "Shape", "shape", ")", "{", "if", "(", "shape", "instanceof", "Rectangle", ")", "{", "Rectangle", "other", "=", "(", "Rectangle", ")", "shape", ";", "if", "(", "(", "x", ">", "(", "other", ".", "x", "+", "other", ".", "width", ")", ")", "||", "(", "(", "x", "+", "width", ")", "<", "other", ".", "x", ")", ")", "{", "return", "false", ";", "}", "if", "(", "(", "y", ">", "(", "other", ".", "y", "+", "other", ".", "height", ")", ")", "||", "(", "(", "y", "+", "height", ")", "<", "other", ".", "y", ")", ")", "{", "return", "false", ";", "}", "return", "true", ";", "}", "else", "if", "(", "shape", "instanceof", "Circle", ")", "{", "return", "intersects", "(", "(", "Circle", ")", "shape", ")", ";", "}", "else", "{", "return", "super", ".", "intersects", "(", "shape", ")", ";", "}", "}" ]

[ "Check", "if", "this", "box", "touches", "another" ]

[ "public", "void", "render", "(", ")", "{", "if", "(", "(", "engine", ".", "usePoints", "(", ")", "&&", "(", "usePoints", "==", "INHERIT_POINTS", ")", ")", "||", "(", "usePoints", "==", "USE_POINTS", ")", ")", "{", "TextureImpl", ".", "bindNone", "(", ")", ";", "GL", ".", "glEnable", "(", "SGL", ".", "GL_POINT_SMOOTH", ")", ";", "GL", ".", "glPointSize", "(", "size", "/", "2", ")", ";", "color", ".", "bind", "(", ")", ";", "GL", ".", "glBegin", "(", "SGL", ".", "GL_POINTS", ")", ";", "GL", ".", "glVertex2f", "(", "x", ",", "y", ")", ";", "GL", ".", "glEnd", "(", ")", ";", "}", "else", "if", "(", "oriented", "||", "scaleY", "!=", "1.0f", ")", "{", "GL", ".", "glPushMatrix", "(", ")", ";", "GL", ".", "glTranslatef", "(", "x", ",", "y", ",", "0f", ")", ";", "if", "(", "oriented", ")", "{", "float", "angle", "=", "(", "float", ")", "(", "Math", ".", "atan2", "(", "y", ",", "x", ")", "*", "180", "/", "Math", ".", "PI", ")", ";", "GL", ".", "glRotatef", "(", "angle", ",", "0f", ",", "0f", ",", "1.0f", ")", ";", "}", "// scale\r", "GL", ".", "glScalef", "(", "1.0f", ",", "scaleY", ",", "1.0f", ")", ";", "image", ".", "draw", "(", "(", "int", ")", "(", "-", "(", "size", "/", "2", ")", ")", ",", "(", "int", ")", "(", "-", "(", "size", "/", "2", ")", ")", ",", "(", "int", ")", "size", ",", "(", "int", ")", "size", ",", "color", ")", ";", "GL", ".", "glPopMatrix", "(", ")", ";", "}", "else", "{", "color", ".", "bind", "(", ")", ";", "image", ".", "drawEmbedded", "(", "(", "int", ")", "(", "x", "-", "(", "size", "/", "2", ")", ")", ",", "(", "int", ")", "(", "y", "-", "(", "size", "/", "2", ")", ")", ",", "(", "int", ")", "size", ",", "(", "int", ")", "size", ")", ";", "}", "}" ]

[ "Render", "this", "particle" ]

[ "public", "void", "update", "(", "int", "delta", ")", "{", "emitter", ".", "updateParticle", "(", "this", ",", "delta", ")", ";", "life", "-=", "delta", ";", "if", "(", "life", ">", "0", ")", "{", "x", "+=", "delta", "*", "velx", ";", "y", "+=", "delta", "*", "vely", ";", "}", "else", "{", "engine", ".", "release", "(", "this", ")", ";", "}", "}" ]

[ "Update", "the", "state", "of", "this", "particle" ]

[ "public", "void", "init", "(", "ParticleEmitter", "emitter", ",", "float", "life", ")", "{", "x", "=", "0", ";", "this", ".", "emitter", "=", "emitter", ";", "y", "=", "0", ";", "velx", "=", "0", ";", "vely", "=", "0", ";", "size", "=", "10", ";", "type", "=", "0", ";", "this", ".", "originalLife", "=", "this", ".", "life", "=", "life", ";", "oriented", "=", "false", ";", "scaleY", "=", "1.0f", ";", "}" ]

[ "Initialise", "the", "state", "of", "the", "particle", "as", "it", "s", "reused" ]

[ "public", "void", "setColor", "(", "float", "r", ",", "float", "g", ",", "float", "b", ",", "float", "a", ")", "{", "if", "(", "color", "==", "Color", ".", "white", ")", "{", "color", "=", "new", "Color", "(", "r", ",", "g", ",", "b", ",", "a", ")", ";", "}", "else", "{", "color", ".", "r", "=", "r", ";", "color", ".", "g", "=", "g", ";", "color", ".", "b", "=", "b", ";", "color", ".", "a", "=", "a", ";", "}", "}" ]

[ "Set", "the", "color", "of", "the", "particle" ]

[ "public", "void", "setVelocity", "(", "float", "dirx", ",", "float", "diry", ",", "float", "speed", ")", "{", "this", ".", "velx", "=", "dirx", "*", "speed", ";", "this", ".", "vely", "=", "diry", "*", "speed", ";", "}" ]

[ "Set", "the", "velocity", "of", "the", "particle" ]

[ "public", "void", "setSpeed", "(", "float", "speed", ")", "{", "float", "currentSpeed", "=", "(", "float", ")", "Math", ".", "sqrt", "(", "(", "velx", "*", "velx", ")", "+", "(", "vely", "*", "vely", ")", ")", ";", "velx", "*=", "speed", ";", "vely", "*=", "speed", ";", "velx", "/=", "currentSpeed", ";", "vely", "/=", "currentSpeed", ";", "}" ]

[ "Set", "the", "current", "speed", "of", "this", "particle" ]

[ "public", "static", "void", "enableSharedContext", "(", ")", "throws", "SlickException", "{", "try", "{", "SHARED_DRAWABLE", "=", "new", "Pbuffer", "(", "64", ",", "64", ",", "new", "PixelFormat", "(", "8", ",", "0", ",", "0", ")", ",", "null", ")", ";", "}", "catch", "(", "LWJGLException", "e", ")", "{", "throw", "new", "SlickException", "(", "\"Unable to create the pbuffer used for shard context, buffers not supported\"", ",", "e", ")", ";", "}", "}" ]

[ "Enable", "shared", "OpenGL", "context", ".", "After", "calling", "this", "all", "containers", "created", "will", "shared", "a", "single", "parent", "context" ]

[ "public", "static", "int", "getBuildVersion", "(", ")", "{", "try", "{", "Properties", "props", "=", "new", "Properties", "(", ")", ";", "props", ".", "load", "(", "ResourceLoader", ".", "getResourceAsStream", "(", "\"version\"", ")", ")", ";", "int", "build", "=", "Integer", ".", "parseInt", "(", "props", ".", "getProperty", "(", "\"build\"", ")", ")", ";", "Log", ".", "info", "(", "\"Slick Build #\"", "+", "build", ")", ";", "return", "build", ";", "}", "catch", "(", "Exception", "e", ")", "{", "Log", ".", "error", "(", "\"Unable to determine Slick build number\"", ")", ";", "return", "-", "1", ";", "}", "}" ]

[ "Get", "the", "build", "number", "of", "slick" ]

[ "public", "void", "sleep", "(", "int", "milliseconds", ")", "{", "long", "target", "=", "getTime", "(", ")", "+", "milliseconds", ";", "while", "(", "getTime", "(", ")", "<", "target", ")", "{", "try", "{", "Thread", ".", "sleep", "(", "1", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "}", "}", "}" ]

[ "Sleep", "for", "a", "given", "period" ]

[ "protected", "void", "updateAndRender", "(", "int", "delta", ")", "throws", "SlickException", "{", "if", "(", "smoothDeltas", ")", "{", "if", "(", "getFPS", "(", ")", "!=", "0", ")", "{", "delta", "=", "1000", "/", "getFPS", "(", ")", ";", "}", "}", "input", ".", "poll", "(", "width", ",", "height", ")", ";", "Music", ".", "poll", "(", "delta", ")", ";", "if", "(", "!", "paused", ")", "{", "storedDelta", "+=", "delta", ";", "if", "(", "storedDelta", ">=", "minimumLogicInterval", ")", "{", "try", "{", "if", "(", "maximumLogicInterval", "!=", "0", ")", "{", "long", "cycles", "=", "storedDelta", "/", "maximumLogicInterval", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "cycles", ";", "i", "++", ")", "{", "game", ".", "update", "(", "this", ",", "(", "int", ")", "maximumLogicInterval", ")", ";", "}", "int", "remainder", "=", "(", "int", ")", "(", "storedDelta", "%", "maximumLogicInterval", ")", ";", "if", "(", "remainder", ">", "minimumLogicInterval", ")", "{", "game", ".", "update", "(", "this", ",", "(", "int", ")", "(", "remainder", "%", "maximumLogicInterval", ")", ")", ";", "storedDelta", "=", "0", ";", "}", "else", "{", "storedDelta", "=", "remainder", ";", "}", "}", "else", "{", "game", ".", "update", "(", "this", ",", "(", "int", ")", "storedDelta", ")", ";", "storedDelta", "=", "0", ";", "}", "}", "catch", "(", "Throwable", "e", ")", "{", "Log", ".", "error", "(", "e", ")", ";", "throw", "new", "SlickException", "(", "\"Game.update() failure - check the game code.\"", ")", ";", "}", "}", "}", "else", "{", "game", ".", "update", "(", "this", ",", "0", ")", ";", "}", "if", "(", "hasFocus", "(", ")", "||", "getAlwaysRender", "(", ")", ")", "{", "if", "(", "clearEachFrame", ")", "{", "GL", ".", "glClear", "(", "SGL", ".", "GL_COLOR_BUFFER_BIT", "|", "SGL", ".", "GL_DEPTH_BUFFER_BIT", ")", ";", "}", "GL", ".", "glLoadIdentity", "(", ")", ";", "graphics", ".", "resetTransform", "(", ")", ";", "graphics", ".", "resetFont", "(", ")", ";", "graphics", ".", "resetLineWidth", "(", ")", ";", "graphics", ".", "setAntiAlias", "(", "false", ")", ";", "try", "{", "game", ".", "render", "(", "this", ",", "graphics", ")", ";", "}", "catch", "(", "Throwable", "e", ")", "{", "Log", ".", "error", "(", "e", ")", ";", "throw", "new", "SlickException", "(", "\"Game.render() failure - check the game code.\"", ")", ";", "}", "graphics", ".", "resetTransform", "(", ")", ";", "if", "(", "showFPS", ")", "{", "defaultFont", ".", "drawString", "(", "10", ",", "10", ",", "\"FPS: \"", "+", "recordedFPS", ")", ";", "}", "GL", ".", "flush", "(", ")", ";", "}", "if", "(", "targetFPS", "!=", "-", "1", ")", "{", "Display", ".", "sync", "(", "targetFPS", ")", ";", "}", "}" ]

[ "Update", "and", "render", "the", "game" ]