[
{
"path": ".gitignore",
"content": "## Java\n\n*.class\n*.war\n*.ear\nhs_err_pid*\nreplay_pid*\n\n## GWT\nwar/\nhtml/war/gwt_bree/\nhtml/gwt-unitCache/\n.apt_generated/\nhtml/war/WEB-INF/deploy/\nhtml/war/WEB-INF/classes/\n.gwt/\ngwt-unitCache/\nwww-test/\n.gwt-tmp/\n\n## Android Studio and Intellij and Android in general\nandroid/libs/armeabi/\nandroid/libs/armeabi-v7a/\nandroid/libs/x86/\nandroid/gen/\n.idea/\n*.ipr\n*.iws\n*.iml\nout/\ncom_crashlytics_export_strings.xml\n\n## Eclipse\n.classpath\n.project\n.metadata\n**/bin/\nbin/\ntmp/\n*.tmp\n*.bak\n*.swp\n*~.nib\nlocal.properties\n.settings/\n.loadpath\n.externalToolBuilders/\n*.launch\n\n## NetBeans\n**/nbproject/private/\nbuild/\nnbbuild/\ndist/\nnbdist/\nnbactions.xml\nnb-configuration.xml\n\n## Gradle\n.gradle\nbuild/\n\n## OS Specific\n.DS_Store\ndocs/\n"
},
{
"path": "CHANGES",
"content": "[Unreleased]\n- Nothing here so far.\n\n[1.4.0]\n- BREAKING CHANGE: Added support for multiple TypingListeners in TypingLabel. Methods \"getTypingListener\" and \"getTypingListeners\" were replaced by \"setTypingListener\" and \"addTypingListener\".\n- Added If Conditionals! {IF=GENDER;f=She;m=He;t=Them;Unknown} -- See details in the wiki.\n- Updated Regexodus dependency for GWT. If you use GWT and inherit Regexodus in your project, follow the installation instructions again, as some of them have changed (namely the `inherits` line).\n- Fixed color tags being applied to the incorrect glyph indices. Thanks @tommyettinger!\n- Fixed alpha not being applied to glyphs not affected by color-altering tokens. Thanks @tommyettinger!\n\n[1.3.0]\n- Fixed Windows line breaks (CR/LF) causing effect tokens to skip characters. This was mostly noticeable when loading strings from a text file.\n- Added `TokenDelimiter` configuration to `TypingConfig`, allowing users to change the token syntax. {CurlyBrackets}, [Brackets], and (Parentheses) are supported.\n- TypingLabel now depends on libGDX 1.11.0, because of differences in how it handles text internally (which this depends on). If you need compatibility with libGDX 1.9.9 through 1.10.0, you must use version 1.2.0 at the latest.\n\n[1.2.0]\n- API Addition: Added isSkipping method to TypingLabel class.\n- Fixed exception being thrown when parsing malformed color values from token arguments.\n- Fixed longer texts not being processed correctly after a setText call. Labels will now restart automatically after a setText call and will also skip to the end in case their progression has already ended.\n- Fixed issue causing labels not to align properly to the X axis.\n- Fixed some issues related to extreme frame rates, both high and low. Now the effects should remain the same independent of the FPS.\n- Fixed color tokens not detecting hex codes without a hash character.\n- Added new SLIDE effect.\n- Added new HANG effect.\n\n[1.1.0]\n- Added global variables that can be set in TypingConfig.GLOBAL_VARS.\n- API Change: Effect::onApply now takes a TypingGlyph instead of Glyph. This might break custom effects.\n- Added new RAINBOW effect.\n- Added new GRADIENT effect.\n- Added new FADE effect.\n- Added new BLINK effect.\n- Added ENDCOLOR token, an alias of CLEARCOLOR, to be consistent with the rest of the tokens.\n\n[1.0.7]\n- Added new WIND effect.\n- Added proper support to HTML / GWT by using RegExodus, thanks tommyettinger! See https://github.com/rafaskb/typing-label/pull/12\n\n[1.0.6]\n- Fixed bug causing glyphs to appear completely out of place.\n\n[1.0.5]\n- Added new SICK effect.\n- Fixed nasty bug causing effects to affect the wrong glyphs after line breaks due to line wraps not being accounted for.\n- Added support for custom effect tokens.\n- API Addition: Added registerEffect and unregisterEffect methods to TypingConfig.\n\n[1.0.4]\n- Fixed bug causing last glyph to be rendered as the first one in some cases.\n\n[1.0.3]\n- API Addition: Notify listener about character progression through the method onChar(Character).\n- API Addition: Added cancelSkipping(), which can be called during events after skipToTheEnd() is called.\n- Fixed variables not being replaced without having a listener set.\n- Fixed exception when using null as text.\n\n[1.0.2]\n- Added a way to replace variables through a listener method, instead of having to provide fixed values.\n- Effect tokens now end previous effects of the same type, to prevent similar effects to stack.\n- Dispose cached glyphs when label is removed from its parent.\n- Fixed bug causing restart() to not actually restart the text when called from listener.end().\n- Fixed bug causing weird effects to glyphs, especially on wrapped labels.\n- Fixed text effects ending at the wrong character.\n- Fixed events being fired at the wrong character.\n\n[1.0.1]\n- Added option to ignore events and effects while skipping to the end.\n- Fixed exception being thrown when the text reached the end.\n- Fixed {WAIT} tokens pausing the text one glyph ahead its position.\n- Fixed TypingLabel.end() being called too many times.\n- Forced all labels to calculate their full layouts. This fixes a bug causing one-line labels to not being rendered at all.\n- Fixed error when creating an empty label.\n\n[1.0.0]\n- Initial code\n"
},
{
"path": "LICENSE",
"content": "MIT License\n\nCopyright (c) 2017 Rafael Skoberg\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE."
},
{
"path": "README.md",
"content": "\n\n# TypingLabel\n\n[](https://search.maven.org/#search%7Cga%7C1%7Ca%3A%22typing-label%22)\n[](https://github.com/rafaskb/typing-label/blob/master/LICENSE)\n\nA libGDX Label that appears as if it was being typed in real time.\n\nIt works as a drop-in replacement for normal [Scene2D Labels](https://libgdx.com/wiki/graphics/2d/scene2d/scene2d-ui#label), and you can use optional [tokens](https://github.com/rafaskb/typing-label/wiki/Tokens) to customize the text's behavior.\n\n\n\n\n## Installation\n\nOpen _build.gradle_ in project root and add this to the _ext_ section under _allprojects_:\n\n```groovy\ntypingLabelVersion = '1.4.0'\nregExodusVersion = '0.1.13' // Only if you're using HTML / GWT\n```\n\n#### Core module\n\nAdd this to your _build.gradle_ core dependencies:\n```groovy\napi \"com.rafaskoberg.gdx:typing-label:$typingLabelVersion\"\n```\n\n> _Note: Replace `api` with `compile` if you're using a Gradle version older than 3.4._\n\n#### HTML dependencies\n###### (Only if you're using HTML / GWT)\n\nAdd this to your _GdxDefinition.gwt.xml_ file:\n```xml\n\n```\n\nAdd this to your _build.gradle_ html dependencies:\n```groovy\napi \"com.github.tommyettinger:regexodus:$regExodusVersion:sources\"\napi \"com.rafaskoberg.gdx:typing-label:$typingLabelVersion:sources\"\n```\n\n> _Note: Replace `api` with `compile` if you're using a Gradle version older than 3.4._\n\n\n## Getting Started\n\nCheck the Wiki:\n- [Usage examples](https://github.com/rafaskb/typing-label/wiki/Examples)\n- [Tokens](https://github.com/rafaskb/typing-label/wiki/Tokens)\n- [Fine tuning](https://github.com/rafaskb/typing-label/wiki/Fine-Tuning)\n- [Custom Effects](https://github.com/rafaskb/typing-label/wiki/Tokens#custom-effects)\n\n## textratypist and SDF / MSDF Support\n_Multi-channel Signed Distance Field_ fonts allow you to prepare and load just one font file and render it in any scale you want, while mantaining the quality and cripsness of the original texture, as if you were working directly with vectors.\n\nSince TypingLabel aims to be a replacement for regular scene2d.ui Labels though, that means it relies on BitmapFonts, which have a specific size and don't work well with scaling.\n\nIf you're using SDF fonts in your project and want TypingLabel features, then make sure to take a look at [Textramode](https://github.com/tommyettinger/textramode) and [Textratypist](https://github.com/tommyettinger/textramode) libraries by [Tommy Ettinger](https://github.com/tommyettinger). They support SDF and MSDF fonts, have much of the TypingLabel features, as well extended markup such as bold and oblique, and much more.\n"
},
{
"path": "build.gradle",
"content": "buildscript {\n repositories {\n mavenLocal()\n mavenCentral()\n maven { url \"https://oss.sonatype.org/content/repositories/snapshots/\" }\n gradlePluginPortal()\n }\n dependencies {\n classpath 'com.vanniktech:gradle-maven-publish-plugin:0.17.0'\n }\n}\n\napply plugin: 'java-library'\napply plugin: 'com.vanniktech.maven.publish'\n\nsourceCompatibility = 1.7\n\ndef projectName = 'typing-label'\nversion \"$VERSION_NAME\"\ngroup 'com.rafaskoberg.gdx'\n\n[compileJava, compileTestJava, javadoc]*.options*.encoding = 'UTF-8'\n\n// Disable JDK 8's doclint\n// http://blog.joda.org/2014/02/turning-off-doclint-in-jdk-8-javadoc.html\nif (JavaVersion.current().isJava8Compatible()) {\n allprojects {\n tasks.withType(Javadoc) {\n // The -quiet is because of some sort of weird JDK JavaCompiler bug:\n // https://discuss.gradle.org/t/passing-arguments-to-compiler-and-javadoc/1661\n options.addStringOption('Xdoclint:none,-missing', '-quiet')\n }\n }\n}\n\nif(JavaVersion.current().isJava9Compatible()) {\n allprojects {\n tasks.withType(JavaCompile) {\n options.release.set(7)\n }\n }\n}\n\nsourceSets.test.resources.srcDirs = [ file('src/test/resources').path ]\n\njavadoc.destinationDir = file('docs/apidocs')\n\njar {\n duplicatesStrategy(DuplicatesStrategy.EXCLUDE)\n archiveBaseName.set(projectName)\n manifest {\n attributes 'Implementation-Title': projectName, 'Implementation-Version': archiveVersion\n }\n}\n\nrepositories {\n mavenCentral()\n maven { url 'https://oss.sonatype.org/content/repositories/snapshots/' }\n}\n\ndependencies {\n api group: 'com.badlogicgames.gdx', name: 'gdx', version: gdxVersion\n api group: 'com.github.tommyettinger', name: 'regexodus', version: regExodusVersion\n testImplementation group: 'com.badlogicgames.gdx', name: 'gdx-backend-lwjgl', version: gdxVersion\n testImplementation group: 'com.badlogicgames.gdx', name: 'gdx-platform', version: gdxVersion, classifier: 'natives-desktop'\n}\n"
},
{
"path": "eclipse-formatter.xml",
"content": "\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n"
},
{
"path": "gradle/wrapper/gradle-wrapper.properties",
"content": "distributionBase=GRADLE_USER_HOME\ndistributionPath=wrapper/dists\ndistributionUrl=https\\://services.gradle.org/distributions/gradle-7.6-bin.zip\nzipStoreBase=GRADLE_USER_HOME\nzipStorePath=wrapper/dists\n"
},
{
"path": "gradle.properties",
"content": "org.gradle.daemon=true\norg.gradle.jvmargs=-Xms128m -Xmx512m -Dfile.encoding=UTF-8 -Dconsole.encoding=UTF-8\norg.gradle.configureondemand=false\n\ngdxVersion=1.11.0\nregExodusVersion=0.1.15\n\nGROUP=com.rafaskoberg.gdx\nPOM_ARTIFACT_ID=typing-label\nVERSION_NAME=1.4.1-SNAPSHOT\n\nPOM_NAME=typing-label\nPOM_DESCRIPTION=A libGDX Label that appears as if it was being typed in real time.\nPOM_INCEPTION_YEAR=2017\n\nPOM_URL=https://github.com/rafaskb/typing-label/\nPOM_SCM_URL=https://github.com/rafaskb/typing-label/\nPOM_SCM_CONNECTION=scm:https://rafaskb@github.com/rafaskb/typing-label.git\nPOM_SCM_DEV_CONNECTION=scm:git://github.com/rafaskb/typing-label.git\n\nPOM_LICENCE_NAME=The MIT License (MIT)\nPOM_LICENCE_URL=https://mit-license.org/\nPOM_LICENCE_DIST=repo\n\nPOM_DEVELOPER_ID=rafaskb\nPOM_DEVELOPER_NAME=Rafa Skoberg\nPOM_DEVELOPER_URL=https://github.com/rafaskb/\nPOM_DEVELOPER_EMAIL=rafa.skoberg@gmail.com\n"
},
{
"path": "gradlew",
"content": "#!/usr/bin/env sh\n\n#\n# Copyright 2015 the original author or authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# https://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#\n\n##############################################################################\n##\n## Gradle start up script for UN*X\n##\n##############################################################################\n\n# Attempt to set APP_HOME\n# Resolve links: $0 may be a link\nPRG=\"$0\"\n# Need this for relative symlinks.\nwhile [ -h \"$PRG\" ] ; do\n ls=`ls -ld \"$PRG\"`\n link=`expr \"$ls\" : '.*-> \\(.*\\)$'`\n if expr \"$link\" : '/.*' > /dev/null; then\n PRG=\"$link\"\n else\n PRG=`dirname \"$PRG\"`\"/$link\"\n fi\ndone\nSAVED=\"`pwd`\"\ncd \"`dirname \\\"$PRG\\\"`/\" >/dev/null\nAPP_HOME=\"`pwd -P`\"\ncd \"$SAVED\" >/dev/null\n\nAPP_NAME=\"Gradle\"\nAPP_BASE_NAME=`basename \"$0\"`\n\n# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.\nDEFAULT_JVM_OPTS='\"-Xmx64m\" \"-Xms64m\"'\n\n# Use the maximum available, or set MAX_FD != -1 to use that value.\nMAX_FD=\"maximum\"\n\nwarn () {\n echo \"$*\"\n}\n\ndie () {\n echo\n echo \"$*\"\n echo\n exit 1\n}\n\n# OS specific support (must be 'true' or 'false').\ncygwin=false\nmsys=false\ndarwin=false\nnonstop=false\ncase \"`uname`\" in\n CYGWIN* )\n cygwin=true\n ;;\n Darwin* )\n darwin=true\n ;;\n MINGW* )\n msys=true\n ;;\n NONSTOP* )\n nonstop=true\n ;;\nesac\n\nCLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar\n\n# Determine the Java command to use to start the JVM.\nif [ -n \"$JAVA_HOME\" ] ; then\n if [ -x \"$JAVA_HOME/jre/sh/java\" ] ; then\n # IBM's JDK on AIX uses strange locations for the executables\n JAVACMD=\"$JAVA_HOME/jre/sh/java\"\n else\n JAVACMD=\"$JAVA_HOME/bin/java\"\n fi\n if [ ! -x \"$JAVACMD\" ] ; then\n die \"ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME\n\nPlease set the JAVA_HOME variable in your environment to match the\nlocation of your Java installation.\"\n fi\nelse\n JAVACMD=\"java\"\n which java >/dev/null 2>&1 || die \"ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.\n\nPlease set the JAVA_HOME variable in your environment to match the\nlocation of your Java installation.\"\nfi\n\n# Increase the maximum file descriptors if we can.\nif [ \"$cygwin\" = \"false\" -a \"$darwin\" = \"false\" -a \"$nonstop\" = \"false\" ] ; then\n MAX_FD_LIMIT=`ulimit -H -n`\n if [ $? -eq 0 ] ; then\n if [ \"$MAX_FD\" = \"maximum\" -o \"$MAX_FD\" = \"max\" ] ; then\n MAX_FD=\"$MAX_FD_LIMIT\"\n fi\n ulimit -n $MAX_FD\n if [ $? -ne 0 ] ; then\n warn \"Could not set maximum file descriptor limit: $MAX_FD\"\n fi\n else\n warn \"Could not query maximum file descriptor limit: $MAX_FD_LIMIT\"\n fi\nfi\n\n# For Darwin, add options to specify how the application appears in the dock\nif $darwin; then\n GRADLE_OPTS=\"$GRADLE_OPTS \\\"-Xdock:name=$APP_NAME\\\" \\\"-Xdock:icon=$APP_HOME/media/gradle.icns\\\"\"\nfi\n\n# For Cygwin or MSYS, switch paths to Windows format before running java\nif [ \"$cygwin\" = \"true\" -o \"$msys\" = \"true\" ] ; then\n APP_HOME=`cygpath --path --mixed \"$APP_HOME\"`\n CLASSPATH=`cygpath --path --mixed \"$CLASSPATH\"`\n JAVACMD=`cygpath --unix \"$JAVACMD\"`\n\n # We build the pattern for arguments to be converted via cygpath\n ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`\n SEP=\"\"\n for dir in $ROOTDIRSRAW ; do\n ROOTDIRS=\"$ROOTDIRS$SEP$dir\"\n SEP=\"|\"\n done\n OURCYGPATTERN=\"(^($ROOTDIRS))\"\n # Add a user-defined pattern to the cygpath arguments\n if [ \"$GRADLE_CYGPATTERN\" != \"\" ] ; then\n OURCYGPATTERN=\"$OURCYGPATTERN|($GRADLE_CYGPATTERN)\"\n fi\n # Now convert the arguments - kludge to limit ourselves to /bin/sh\n i=0\n for arg in \"$@\" ; do\n CHECK=`echo \"$arg\"|egrep -c \"$OURCYGPATTERN\" -`\n CHECK2=`echo \"$arg\"|egrep -c \"^-\"` ### Determine if an option\n\n if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition\n eval `echo args$i`=`cygpath --path --ignore --mixed \"$arg\"`\n else\n eval `echo args$i`=\"\\\"$arg\\\"\"\n fi\n i=`expr $i + 1`\n done\n case $i in\n 0) set -- ;;\n 1) set -- \"$args0\" ;;\n 2) set -- \"$args0\" \"$args1\" ;;\n 3) set -- \"$args0\" \"$args1\" \"$args2\" ;;\n 4) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" ;;\n 5) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" ;;\n 6) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" \"$args5\" ;;\n 7) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" \"$args5\" \"$args6\" ;;\n 8) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" \"$args5\" \"$args6\" \"$args7\" ;;\n 9) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" \"$args5\" \"$args6\" \"$args7\" \"$args8\" ;;\n esac\nfi\n\n# Escape application args\nsave () {\n for i do printf %s\\\\n \"$i\" | sed \"s/'/'\\\\\\\\''/g;1s/^/'/;\\$s/\\$/' \\\\\\\\/\" ; done\n echo \" \"\n}\nAPP_ARGS=`save \"$@\"`\n\n# Collect all arguments for the java command, following the shell quoting and substitution rules\neval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS \"\\\"-Dorg.gradle.appname=$APP_BASE_NAME\\\"\" -classpath \"\\\"$CLASSPATH\\\"\" org.gradle.wrapper.GradleWrapperMain \"$APP_ARGS\"\n\nexec \"$JAVACMD\" \"$@\"\n"
},
{
"path": "gradlew.bat",
"content": "@rem\r\n@rem Copyright 2015 the original author or authors.\r\n@rem\r\n@rem Licensed under the Apache License, Version 2.0 (the \"License\");\r\n@rem you may not use this file except in compliance with the License.\r\n@rem You may obtain a copy of the License at\r\n@rem\r\n@rem https://www.apache.org/licenses/LICENSE-2.0\r\n@rem\r\n@rem Unless required by applicable law or agreed to in writing, software\r\n@rem distributed under the License is distributed on an \"AS IS\" BASIS,\r\n@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n@rem See the License for the specific language governing permissions and\r\n@rem limitations under the License.\r\n@rem\r\n\r\n@if \"%DEBUG%\" == \"\" @echo off\r\n@rem ##########################################################################\r\n@rem\r\n@rem Gradle startup script for Windows\r\n@rem\r\n@rem ##########################################################################\r\n\r\n@rem Set local scope for the variables with windows NT shell\r\nif \"%OS%\"==\"Windows_NT\" setlocal\r\n\r\nset DIRNAME=%~dp0\r\nif \"%DIRNAME%\" == \"\" set DIRNAME=.\r\nset APP_BASE_NAME=%~n0\r\nset APP_HOME=%DIRNAME%\r\n\r\n@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.\r\nset DEFAULT_JVM_OPTS=\"-Xmx64m\" \"-Xms64m\"\r\n\r\n@rem Find java.exe\r\nif defined JAVA_HOME goto findJavaFromJavaHome\r\n\r\nset JAVA_EXE=java.exe\r\n%JAVA_EXE% -version >NUL 2>&1\r\nif \"%ERRORLEVEL%\" == \"0\" goto init\r\n\r\necho.\r\necho ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.\r\necho.\r\necho Please set the JAVA_HOME variable in your environment to match the\r\necho location of your Java installation.\r\n\r\ngoto fail\r\n\r\n:findJavaFromJavaHome\r\nset JAVA_HOME=%JAVA_HOME:\"=%\r\nset JAVA_EXE=%JAVA_HOME%/bin/java.exe\r\n\r\nif exist \"%JAVA_EXE%\" goto init\r\n\r\necho.\r\necho ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%\r\necho.\r\necho Please set the JAVA_HOME variable in your environment to match the\r\necho location of your Java installation.\r\n\r\ngoto fail\r\n\r\n:init\r\n@rem Get command-line arguments, handling Windows variants\r\n\r\nif not \"%OS%\" == \"Windows_NT\" goto win9xME_args\r\n\r\n:win9xME_args\r\n@rem Slurp the command line arguments.\r\nset CMD_LINE_ARGS=\r\nset _SKIP=2\r\n\r\n:win9xME_args_slurp\r\nif \"x%~1\" == \"x\" goto execute\r\n\r\nset CMD_LINE_ARGS=%*\r\n\r\n:execute\r\n@rem Setup the command line\r\n\r\nset CLASSPATH=%APP_HOME%\\gradle\\wrapper\\gradle-wrapper.jar\r\n\r\n@rem Execute Gradle\r\n\"%JAVA_EXE%\" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% \"-Dorg.gradle.appname=%APP_BASE_NAME%\" -classpath \"%CLASSPATH%\" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%\r\n\r\n:end\r\n@rem End local scope for the variables with windows NT shell\r\nif \"%ERRORLEVEL%\"==\"0\" goto mainEnd\r\n\r\n:fail\r\nrem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of\r\nrem the _cmd.exe /c_ return code!\r\nif not \"\" == \"%GRADLE_EXIT_CONSOLE%\" exit 1\r\nexit /b 1\r\n\r\n:mainEnd\r\nif \"%OS%\"==\"Windows_NT\" endlocal\r\n\r\n:omega\r\n"
},
{
"path": "jitpack.yml",
"content": "jdk:\n - openjdk16\ninstall:\n - echo \"Installing with Gradle\"\n - chmod 755 gradlew\n - ./gradlew clean publishToMavenLocal -x signMavenPublication\n"
},
{
"path": "src/main/java/com/rafaskoberg/gdx/typinglabel/Effect.java",
"content": "\npackage com.rafaskoberg.gdx.typinglabel;\n\nimport com.badlogic.gdx.graphics.Color;\nimport com.badlogic.gdx.math.Interpolation;\nimport com.badlogic.gdx.math.MathUtils;\n\n/** Abstract text effect. */\npublic abstract class Effect {\n private static final float FADEOUT_SPLIT = 0.25f;\n protected final TypingLabel label;\n public int indexStart = -1;\n public int indexEnd = -1;\n public float duration = Float.POSITIVE_INFINITY;\n protected float totalTime;\n\n public Effect(TypingLabel label) {\n this.label = label;\n }\n\n public void update(float delta) {\n totalTime += delta;\n }\n\n /** Applies the effect to the given glyph. */\n public final void apply(TypingGlyph glyph, int glyphIndex, float delta) {\n int localIndex = glyphIndex - indexStart;\n onApply(glyph, localIndex, delta);\n }\n\n /** Called when this effect should be applied to the given glyph. */\n protected abstract void onApply(TypingGlyph glyph, int localIndex, float delta);\n\n /** Returns whether or not this effect is finished and should be removed. Note that effects are infinite by default. */\n public boolean isFinished() {\n return totalTime > duration;\n }\n\n /** Calculates the fadeout of this effect, if any. Only considers the second half of the duration. */\n protected float calculateFadeout() {\n if(Float.isInfinite(duration)) return 1;\n\n // Calculate raw progress\n float progress = MathUtils.clamp(totalTime / duration, 0, 1);\n\n // If progress is before the split point, return a full factor\n if(progress < FADEOUT_SPLIT) return 1;\n\n // Otherwise calculate from the split point\n return Interpolation.smooth.apply(1, 0, (progress - FADEOUT_SPLIT) / (1f - FADEOUT_SPLIT));\n }\n\n /**\n * Calculates a linear progress dividing the total time by the given modifier. Returns a value between 0 and 1 that\n * loops in a ping-pong mode.\n */\n protected float calculateProgress(float modifier) {\n return calculateProgress(modifier, 0, true);\n }\n\n /**\n * Calculates a linear progress dividing the total time by the given modifier. Returns a value between 0 and 1 that\n * loops in a ping-pong mode.\n */\n protected float calculateProgress(float modifier, float offset) {\n return calculateProgress(modifier, offset, true);\n }\n\n /** Calculates a linear progress dividing the total time by the given modifier. Returns a value between 0 and 1. */\n protected float calculateProgress(float modifier, float offset, boolean pingpong) {\n float progress = totalTime / modifier + offset;\n while(progress < 0.0f) {\n progress += 2.0f;\n }\n if(pingpong) {\n progress %= 2f;\n if(progress > 1.0f) progress = 1f - (progress - 1f);\n } else {\n progress %= 1.0f;\n }\n progress = MathUtils.clamp(progress, 0, 1);\n return progress;\n }\n\n /** Returns the line height of the label controlling this effect. */\n protected float getLineHeight() {\n return label.getBitmapFontCache().getFont().getLineHeight() * label.getFontScaleY();\n }\n\n /** Returns a float value parsed from the given String, or the default value if the string couldn't be parsed. */\n protected float paramAsFloat(String str, float defaultValue) {\n return Parser.stringToFloat(str, defaultValue);\n }\n\n /** Returns a boolean value parsed from the given String, or the default value if the string couldn't be parsed. */\n protected boolean paramAsBoolean(String str) {\n return Parser.stringToBoolean(str);\n }\n\n /** Parses a color from the given string. Returns null if the color couldn't be parsed. */\n protected Color paramAsColor(String str) {\n return Parser.stringToColor(str);\n }\n\n}\n"
},
{
"path": "src/main/java/com/rafaskoberg/gdx/typinglabel/GlyphUtils.java",
"content": "\npackage com.rafaskoberg.gdx.typinglabel;\n\nimport com.badlogic.gdx.graphics.g2d.BitmapFont.Glyph;\nimport com.badlogic.gdx.utils.Array;\nimport com.badlogic.gdx.utils.Pool;\nimport com.badlogic.gdx.utils.ReflectionPool;\n\n/** Utility class to manage {@link Glyph} pooling and cloning. */\nclass GlyphUtils {\n private static final Pool pool = new ReflectionPool(TypingGlyph.class) {\n protected void reset(TypingGlyph glyph) {\n GlyphUtils.reset(glyph);\n }\n };\n\n /**\n * Returns a glyph from this pool. The glyph may be new (from {@link Pool#newObject()}) or reused (previously {@link\n * Pool#free(Object) freed}).\n */\n static TypingGlyph obtain() {\n return pool.obtain();\n }\n\n /**\n * Returns a glyph from this pool and clones it from the given one. The glyph may be new (from {@link\n * Pool#newObject()}) or reused (previously {@link Pool#free(Object) freed}).\n */\n static Glyph obtainClone(Glyph from) {\n TypingGlyph glyph = pool.obtain();\n clone(from, glyph);\n return glyph;\n }\n\n /**\n * Puts the specified glyph in the pool, making it eligible to be returned by {@link #obtain()}. If the pool already\n * contains {@link Pool#max} free glyphs, the specified glyph is reset but not added to the pool.\n */\n static void free(TypingGlyph glyph) {\n pool.free(glyph);\n }\n\n /**\n * Puts the specified glyphs in the pool. Null glyphs within the array are silently ignored.\n *\n * @see Pool#free(Object)\n */\n static void freeAll(Array glyphs) {\n pool.freeAll(glyphs);\n }\n\n /** Called when a glyph is freed to clear the state of the glyph for possible later reuse. */\n static void reset(TypingGlyph glyph) {\n glyph.id = 0;\n glyph.srcX = 0;\n glyph.srcY = 0;\n glyph.width = 0;\n glyph.height = 0;\n glyph.u = 0;\n glyph.v = 0;\n glyph.u2 = 0;\n glyph.v2 = 0;\n glyph.xoffset = 0;\n glyph.yoffset = 0;\n glyph.xadvance = 0;\n glyph.kerning = null;\n glyph.fixedWidth = false;\n\n glyph.runColor = 0xFFFFFFFF;\n glyph.internalIndex = -1;\n glyph.color = null;\n }\n\n /** Copies all contents from the first glyph to the second one. */\n static void clone(Glyph from, TypingGlyph to) {\n to.id = from.id;\n to.srcX = from.srcX;\n to.srcY = from.srcY;\n to.width = from.width;\n to.height = from.height;\n to.u = from.u;\n to.v = from.v;\n to.u2 = from.u2;\n to.v2 = from.v2;\n to.xoffset = from.xoffset;\n to.yoffset = from.yoffset;\n to.xadvance = from.xadvance;\n to.kerning = from.kerning; // Keep the same instance, there's no reason to deep clone it\n to.fixedWidth = from.fixedWidth;\n\n to.runColor = 0xFFFFFFFF;\n to.internalIndex = -1;\n to.color = null;\n }\n\n}\n"
},
{
"path": "src/main/java/com/rafaskoberg/gdx/typinglabel/InternalToken.java",
"content": "\npackage com.rafaskoberg.gdx.typinglabel;\n\nenum InternalToken {\n // @formatter:off\n\t// Public\n\tWAIT (\"WAIT\", TokenCategory.WAIT ),\n\tSPEED (\"SPEED\", TokenCategory.SPEED ),\n\tSLOWER (\"SLOWER\", TokenCategory.SPEED ),\n\tSLOW (\"SLOW\", TokenCategory.SPEED ),\n\tNORMAL (\"NORMAL\", TokenCategory.SPEED ),\n\tFAST (\"FAST\", TokenCategory.SPEED ),\n\tFASTER (\"FASTER\", TokenCategory.SPEED ),\n\tCOLOR (\"COLOR\", TokenCategory.COLOR ),\n\tCLEARCOLOR (\"CLEARCOLOR\", TokenCategory.COLOR ),\n\tENDCOLOR (\"ENDCOLOR\", TokenCategory.COLOR ),\n\tVAR (\"VAR\", TokenCategory.VARIABLE ),\n\tIF (\"IF\", TokenCategory.IF ),\n\tEVENT (\"EVENT\", TokenCategory.EVENT ),\n\tRESET (\"RESET\", TokenCategory.RESET ),\n\tSKIP (\"SKIP\", TokenCategory.SKIP );\n\t// @formatter:on\n\n final String name;\n final TokenCategory category;\n\n private InternalToken(String name, TokenCategory category) {\n this.name = name;\n this.category = category;\n }\n\n @Override\n public String toString() {\n return name;\n }\n\n static InternalToken fromName(String name) {\n if(name != null) {\n for(InternalToken token : values()) {\n if(name.equalsIgnoreCase(token.name)) {\n return token;\n }\n }\n }\n return null;\n }\n}\n"
},
{
"path": "src/main/java/com/rafaskoberg/gdx/typinglabel/Parser.java",
"content": "\npackage com.rafaskoberg.gdx.typinglabel;\n\nimport com.badlogic.gdx.graphics.Color;\nimport com.badlogic.gdx.graphics.Colors;\nimport com.badlogic.gdx.math.MathUtils;\nimport com.badlogic.gdx.utils.Array;\nimport com.badlogic.gdx.utils.reflect.ClassReflection;\nimport com.badlogic.gdx.utils.reflect.Constructor;\nimport com.badlogic.gdx.utils.reflect.ReflectionException;\nimport regexodus.Matcher;\nimport regexodus.Pattern;\nimport regexodus.REFlags;\n\n/** Utility class to parse tokens from a {@link TypingLabel}. */\nclass Parser {\n private static TokenDelimiter CURRENT_DELIMITER = TypingConfig.TOKEN_DELIMITER;\n private static Pattern PATTERN_TOKEN_STRIP = compileTokenPattern();\n private static Pattern PATTERN_MARKUP_STRIP = Pattern.compile(\"(\\\\[{2})|(\\\\[#?\\\\w*(\\\\[|\\\\])?)\");\n\n private static final Pattern PATTERN_COLOR_HEX_NO_HASH = Pattern.compile(\"[A-F0-9]{6}\");\n\n private static final String[] BOOLEAN_TRUE = {\"true\", \"yes\", \"t\", \"y\", \"on\", \"1\"};\n private static final int INDEX_TOKEN = 1;\n private static final int INDEX_PARAM = 2;\n\n private static String RESET_REPLACEMENT;\n\n /** Parses all tokens from the given {@link TypingLabel}. */\n static void parseTokens(TypingLabel label) {\n // Detect if token delimiter has changed\n boolean hasDelimiterChanged = CURRENT_DELIMITER != TypingConfig.TOKEN_DELIMITER;\n if(hasDelimiterChanged) {\n CURRENT_DELIMITER = TypingConfig.TOKEN_DELIMITER;\n }\n\n // Compile patterns if necessary\n if(PATTERN_TOKEN_STRIP == null || TypingConfig.dirtyEffectMaps || hasDelimiterChanged) {\n PATTERN_TOKEN_STRIP = compileTokenPattern();\n }\n if(RESET_REPLACEMENT == null || TypingConfig.dirtyEffectMaps || hasDelimiterChanged) {\n RESET_REPLACEMENT = getResetReplacement();\n }\n\n // Adjust and check markup color\n if(label.forceMarkupColor) label.getBitmapFontCache().getFont().getData().markupEnabled = true;\n\n // Remove any previous entries\n label.tokenEntries.clear();\n\n // Parse all tokens with text replacements, namely color and var.\n parseReplacements(label);\n\n // Parse all regular tokens and properly register them\n parseRegularTokens(label);\n\n // Parse color markups and register SKIP tokens\n parseColorMarkups(label);\n\n // Sort token entries\n label.tokenEntries.sort();\n label.tokenEntries.reverse();\n }\n\n /** Parse tokens that only replace text, such as colors and variables. */\n private static void parseReplacements(TypingLabel label) {\n // Get text\n CharSequence text = label.getText();\n boolean hasMarkup = label.getBitmapFontCache().getFont().getData().markupEnabled;\n\n // Create string builder\n StringBuilder sb = new StringBuilder(text.length());\n Matcher m = PATTERN_TOKEN_STRIP.matcher(text);\n int matcherIndexOffset = 0;\n\n // Iterate through matches\n while(true) {\n // Reset StringBuilder and matcher\n sb.setLength(0);\n m.setTarget(text);\n m.setPosition(matcherIndexOffset);\n\n // Make sure there's at least one regex match\n if(!m.find()) break;\n\n // Get token and parameter\n final InternalToken internalToken = InternalToken.fromName(m.group(INDEX_TOKEN));\n final String param = m.group(INDEX_PARAM);\n\n // If token couldn't be parsed, move one index forward to continue the search\n if(internalToken == null) {\n matcherIndexOffset++;\n continue;\n }\n\n // Process tokens and handle replacement\n String replacement = \"\";\n switch(internalToken) {\n case COLOR:\n if(hasMarkup) replacement = stringToColorMarkup(param);\n break;\n case ENDCOLOR:\n case CLEARCOLOR:\n if(hasMarkup) replacement = \"[#\" + label.getClearColor().toString() + \"]\";\n break;\n case VAR:\n replacement = null;\n\n // Try to replace variable through listeners.\n for(TypingListener listener : label.getTypingListeners()) {\n replacement = listener.replaceVariable(param);\n if(replacement != null) break;\n }\n\n // If replacement is null, get value from maps.\n if(replacement == null) {\n replacement = label.getVariables().get(param.toUpperCase());\n }\n\n // If replacement is still null, get value from global scope\n if(replacement == null) {\n replacement = TypingConfig.GLOBAL_VARS.get(param.toUpperCase());\n }\n\n // Make sure we're not inserting \"null\" to the text.\n if(replacement == null) replacement = param.toUpperCase();\n break;\n case IF:\n // Process token\n replacement = processIfToken(label, param);\n\n // Make sure we're not inserting \"null\" to the text.\n if(replacement == null) replacement = param.toUpperCase();\n\n break;\n case RESET:\n replacement = RESET_REPLACEMENT + label.getDefaultToken();\n break;\n default:\n // We don't want to process this token now. Move one index forward to continue the search\n matcherIndexOffset++;\n continue;\n }\n\n // Update text with replacement\n m.setPosition(m.start());\n text = m.replaceFirst(replacement);\n }\n\n // Set new text\n label.setText(text, false, false);\n }\n\n private static String processIfToken(TypingLabel label, String paramsString) {\n // Split params\n final String[] params = paramsString == null ? new String[0] : paramsString.split(\";\");\n final String variable = params.length > 0 ? params[0] : null;\n\n // Ensure our params are valid\n if(params.length <= 1 || variable == null) {\n return null;\n }\n\n /*\n Get variable's value\n */\n String variableValue = null;\n\n // Try to get value through listener.\n for(TypingListener listener : label.getTypingListeners()) {\n variableValue = listener.replaceVariable(variable);\n if(variableValue != null) break;\n }\n\n // If value is null, get it from maps.\n if(variableValue == null) {\n variableValue = label.getVariables().get(variable.toUpperCase());\n }\n\n // If value is still null, get it from global scope\n if(variableValue == null) {\n variableValue = TypingConfig.GLOBAL_VARS.get(variable.toUpperCase());\n }\n\n // Ensure variable is never null\n if(variableValue == null) {\n variableValue = \"\";\n }\n\n // Iterate through params and try to find a match\n String defaultValue = null;\n for(int i = 1, n = params.length; i < n; i++) {\n String[] subParams = params[i].split(\"=\", 2);\n String key = subParams[0];\n String value = subParams[subParams.length - 1];\n boolean isKeyValid = subParams.length > 1 && !key.isEmpty();\n\n // If key isn't valid, it must be a default value. Store it and carry on\n if(!isKeyValid) {\n defaultValue = value;\n break;\n }\n\n // Compare variable's value with key\n if(variableValue.equalsIgnoreCase(key)) {\n return value;\n }\n }\n\n // Try to return any default values captured during the iteration\n if(defaultValue != null) {\n return defaultValue;\n }\n\n // If we got this far, no values matched our variable.\n // Return the variable itself, which might be useful for debugging.\n return variable;\n }\n\n /** Parses regular tokens that don't need replacement and register their indexes in the {@link TypingLabel}. */\n private static void parseRegularTokens(TypingLabel label) {\n // Get text\n CharSequence text = label.getText();\n\n // Create matcher and StringBuilder\n Matcher m = PATTERN_TOKEN_STRIP.matcher(text);\n StringBuilder sb = new StringBuilder(text.length());\n int matcherIndexOffset = 0;\n\n // Iterate through matches\n while(true) {\n // Reset matcher and StringBuilder\n m.setTarget(text);\n sb.setLength(0);\n m.setPosition(matcherIndexOffset);\n\n // Make sure there's at least one regex match\n if(!m.find()) break;\n\n // Get token name and category\n String tokenName = m.group(INDEX_TOKEN).toUpperCase();\n TokenCategory tokenCategory = null;\n InternalToken tmpToken = InternalToken.fromName(tokenName);\n if(tmpToken == null) {\n if(TypingConfig.EFFECT_START_TOKENS.containsKey(tokenName)) {\n tokenCategory = TokenCategory.EFFECT_START;\n } else if(TypingConfig.EFFECT_END_TOKENS.containsKey(tokenName)) {\n tokenCategory = TokenCategory.EFFECT_END;\n }\n } else {\n tokenCategory = tmpToken.category;\n }\n\n // Get token, param and index of where the token begins\n int groupCount = m.groupCount();\n final String paramsString = groupCount == INDEX_PARAM ? m.group(INDEX_PARAM) : null;\n final String[] params = paramsString == null ? new String[0] : paramsString.split(\";\");\n final String firstParam = params.length > 0 ? params[0] : null;\n final int index = m.start(0);\n int indexOffset = 0;\n\n // If token couldn't be parsed, move one index forward to continue the search\n if(tokenCategory == null) {\n matcherIndexOffset++;\n continue;\n }\n\n // Process tokens\n float floatValue = 0;\n String stringValue = null;\n Effect effect = null;\n\n switch(tokenCategory) {\n case WAIT: {\n floatValue = stringToFloat(firstParam, TypingConfig.DEFAULT_WAIT_VALUE);\n break;\n }\n case EVENT: {\n stringValue = paramsString;\n indexOffset = -1;\n break;\n }\n case SPEED: {\n switch(tokenName) {\n case \"SPEED\":\n float minModifier = TypingConfig.MIN_SPEED_MODIFIER;\n float maxModifier = TypingConfig.MAX_SPEED_MODIFIER;\n float modifier = MathUtils.clamp(stringToFloat(firstParam, 1), minModifier, maxModifier);\n floatValue = TypingConfig.DEFAULT_SPEED_PER_CHAR / modifier;\n break;\n case \"SLOWER\":\n floatValue = TypingConfig.DEFAULT_SPEED_PER_CHAR / 0.500f;\n break;\n case \"SLOW\":\n floatValue = TypingConfig.DEFAULT_SPEED_PER_CHAR / 0.667f;\n break;\n case \"NORMAL\":\n floatValue = TypingConfig.DEFAULT_SPEED_PER_CHAR;\n break;\n case \"FAST\":\n floatValue = TypingConfig.DEFAULT_SPEED_PER_CHAR / 2.000f;\n break;\n case \"FASTER\":\n floatValue = TypingConfig.DEFAULT_SPEED_PER_CHAR / 4.000f;\n break;\n }\n break;\n }\n case EFFECT_START: {\n Class clazz = TypingConfig.EFFECT_START_TOKENS.get(tokenName.toUpperCase());\n try {\n if(clazz != null) {\n Constructor constructor = ClassReflection.getConstructors(clazz)[0];\n int constructorParamCount = constructor.getParameterTypes().length;\n if(constructorParamCount >= 2) {\n effect = (Effect) constructor.newInstance(label, params);\n } else {\n effect = (Effect) constructor.newInstance(label);\n }\n }\n } catch(ReflectionException e) {\n String message = \"Failed to initialize \" + tokenName + \" effect token. Make sure the associated class (\" + clazz + \") has only one constructor with TypingLabel as first parameter and optionally String[] as second.\";\n throw new IllegalStateException(message, e);\n }\n break;\n }\n case EFFECT_END: {\n break;\n }\n }\n\n // Register token\n TokenEntry entry = new TokenEntry(tokenName, tokenCategory, index + indexOffset, floatValue, stringValue);\n entry.effect = effect;\n label.tokenEntries.add(entry);\n\n // Set new text without tokens\n m.setPosition(0);\n text = m.replaceFirst(\"\");\n }\n\n // Update label text\n label.setText(text, false, false);\n }\n\n /** Parse color markup tags and register SKIP tokens. */\n private static void parseColorMarkups(TypingLabel label) {\n // Get text\n final CharSequence text = label.getText();\n\n // Iterate through matches and register skip tokens\n Matcher m = PATTERN_MARKUP_STRIP.matcher(text);\n while(m.find()) {\n final String tag = m.group(0);\n final int index = m.start(0);\n label.tokenEntries.add(new TokenEntry(\"SKIP\", TokenCategory.SKIP, index, 0, tag));\n }\n }\n\n /** Returns a float value parsed from the given String, or the default value if the string couldn't be parsed. */\n static float stringToFloat(String str, float defaultValue) {\n if(str != null) {\n try {\n return Float.parseFloat(str);\n } catch(Exception e) {\n }\n }\n return defaultValue;\n }\n\n /** Returns a boolean value parsed from the given String, or the default value if the string couldn't be parsed. */\n static boolean stringToBoolean(String str) {\n if(str != null) {\n for(String booleanTrue : BOOLEAN_TRUE) {\n if(booleanTrue.equalsIgnoreCase(str)) {\n return true;\n }\n }\n }\n return false;\n }\n\n /** Parses a color from the given string. Returns null if the color couldn't be parsed. */\n static Color stringToColor(String str) {\n if(str != null) {\n\n // Try to parse named color\n Color namedColor = Colors.get(str.toUpperCase());\n if(namedColor != null) {\n return new Color(namedColor);\n }\n\n // Try to parse hex\n if(str.length() >= 6) {\n try {\n return Color.valueOf(str);\n } catch(NumberFormatException ignored) {\n }\n }\n }\n\n return null;\n }\n\n /** Encloses the given string in brackets to work as a regular color markup tag. */\n private static String stringToColorMarkup(String str) {\n if(str != null) {\n // Upper case\n str = str.toUpperCase();\n\n // If color isn't registered by name, try to parse it as an hex code.\n Color namedColor = Colors.get(str);\n if(namedColor == null) {\n boolean isHexWithoutHashChar = str.length() >= 6 && PATTERN_COLOR_HEX_NO_HASH.matches(str);\n if(isHexWithoutHashChar) {\n str = \"#\" + str;\n }\n }\n }\n\n // Return color code\n return \"[\" + str + \"]\";\n }\n\n /**\n * Returns a compiled {@link Pattern} that groups the token name in the first group and the params in an optional second one. Case\n * insensitive.\n */\n private static Pattern compileTokenPattern() {\n StringBuilder sb = new StringBuilder();\n sb.append(\"\\\\\").append(CURRENT_DELIMITER.open).append(\"(\");\n Array tokens = new Array<>();\n TypingConfig.EFFECT_START_TOKENS.keys().toArray(tokens);\n TypingConfig.EFFECT_END_TOKENS.keys().toArray(tokens);\n for(InternalToken token : InternalToken.values()) {\n tokens.add(token.name);\n }\n for(int i = 0; i < tokens.size; i++) {\n sb.append(tokens.get(i));\n if((i + 1) < tokens.size) sb.append('|');\n }\n sb.append(\")(?:=([;:?=^_ #-'*-.\\\\.\\\\w]+))?\\\\\").append(CURRENT_DELIMITER.close);\n return Pattern.compile(sb.toString(), REFlags.IGNORE_CASE);\n }\n\n /** Returns the replacement string intended to be used on {RESET} tokens. */\n private static String getResetReplacement() {\n Array tokens = new Array<>();\n TypingConfig.EFFECT_END_TOKENS.keys().toArray(tokens);\n tokens.add(\"CLEARCOLOR\");\n tokens.add(\"NORMAL\");\n\n StringBuilder sb = new StringBuilder();\n for(String token : tokens) {\n sb.append(CURRENT_DELIMITER.open).append(token).append(CURRENT_DELIMITER.close);\n }\n return sb.toString();\n }\n\n}\n"
},
{
"path": "src/main/java/com/rafaskoberg/gdx/typinglabel/TokenCategory.java",
"content": "package com.rafaskoberg.gdx.typinglabel;\n\npublic enum TokenCategory {\n WAIT,\n SPEED,\n COLOR,\n VARIABLE,\n IF,\n EVENT,\n RESET,\n SKIP,\n EFFECT_START,\n EFFECT_END\n}\n"
},
{
"path": "src/main/java/com/rafaskoberg/gdx/typinglabel/TokenDelimiter.java",
"content": "package com.rafaskoberg.gdx.typinglabel;\n\n/**\n * Enum that lists all supported delimiters for tokens.\n */\npublic enum TokenDelimiter {\n /** {TOKEN} */\n CURLY_BRACKETS('{', '}'),\n\n /** [TOKEN] */\n BRACKETS('[', ']'),\n\n /** (TOKEN) */\n PARENTHESES('(', ')');\n\n public final char open;\n public final char close;\n\n TokenDelimiter(char open, char close) {\n this.open = open;\n this.close = close;\n }\n}\n"
},
{
"path": "src/main/java/com/rafaskoberg/gdx/typinglabel/TokenEntry.java",
"content": "\npackage com.rafaskoberg.gdx.typinglabel;\n\n/** Container representing a token, parsed parameters and its position in text. */\nclass TokenEntry implements Comparable {\n String token;\n TokenCategory category;\n int index;\n float floatValue;\n String stringValue;\n Effect effect;\n\n TokenEntry(String token, TokenCategory category, int index, float floatValue, String stringValue) {\n this.token = token;\n this.category = category;\n this.index = index;\n this.floatValue = floatValue;\n this.stringValue = stringValue;\n }\n\n @Override\n public int compareTo(TokenEntry o) {\n return Integer.compare(index, o.index);\n }\n\n}\n"
},
{
"path": "src/main/java/com/rafaskoberg/gdx/typinglabel/TypingAdapter.java",
"content": "\npackage com.rafaskoberg.gdx.typinglabel;\n\n/** Simple listener for label events. You can derive from this and only override what you are interested in. */\npublic class TypingAdapter implements TypingListener {\n\n @Override\n public void event(String event) {\n }\n\n @Override\n public void end() {\n }\n\n @Override\n public String replaceVariable(String variable) {\n return null;\n }\n\n @Override\n public void onChar(Character ch) {\n }\n\n}\n"
},
{
"path": "src/main/java/com/rafaskoberg/gdx/typinglabel/TypingConfig.java",
"content": "\npackage com.rafaskoberg.gdx.typinglabel;\n\nimport com.badlogic.gdx.graphics.Color;\nimport com.badlogic.gdx.utils.ObjectFloatMap;\nimport com.badlogic.gdx.utils.ObjectMap;\nimport com.rafaskoberg.gdx.typinglabel.effects.BlinkEffect;\nimport com.rafaskoberg.gdx.typinglabel.effects.EaseEffect;\nimport com.rafaskoberg.gdx.typinglabel.effects.FadeEffect;\nimport com.rafaskoberg.gdx.typinglabel.effects.GradientEffect;\nimport com.rafaskoberg.gdx.typinglabel.effects.HangEffect;\nimport com.rafaskoberg.gdx.typinglabel.effects.JumpEffect;\nimport com.rafaskoberg.gdx.typinglabel.effects.RainbowEffect;\nimport com.rafaskoberg.gdx.typinglabel.effects.ShakeEffect;\nimport com.rafaskoberg.gdx.typinglabel.effects.SickEffect;\nimport com.rafaskoberg.gdx.typinglabel.effects.SlideEffect;\nimport com.rafaskoberg.gdx.typinglabel.effects.WaveEffect;\nimport com.rafaskoberg.gdx.typinglabel.effects.WindEffect;\n\n/** Configuration class that easily allows the user to fine tune the library's functionality. */\npublic class TypingConfig {\n\n /**\n * Whether or not LibGDX's Color Markup\n * Language should be enabled when parsing a {@link TypingLabel}. Note that this library doesn't truly handle\n * colors, but simply convert them to the markup format. If markup is disabled, color tokens will be ignored.\n */\n public static boolean FORCE_COLOR_MARKUP_BY_DEFAULT = true;\n\n /** Default time in seconds that an empty {@code WAIT} token should wait for. Default value is {@code 0.250}. */\n public static float DEFAULT_WAIT_VALUE = 0.250f;\n\n /** Time in seconds that takes for each char to appear in the default speed. Default value is {@code 0.035}. */\n public static float DEFAULT_SPEED_PER_CHAR = 0.035f;\n\n /**\n * Minimum value for the {@code SPEED} token. This value divides {@link #DEFAULT_SPEED_PER_CHAR} to calculate the\n * final speed. Keep it above zero. Default value is {@code 0.001}.\n */\n public static float MIN_SPEED_MODIFIER = 0.001f;\n\n /**\n * Maximum value for the {@code SPEED} token. This value divides {@link #DEFAULT_SPEED_PER_CHAR} to calculate the\n * final speed. Default value is {@code 100}.\n */\n public static float MAX_SPEED_MODIFIER = 100.0f;\n\n /**\n * Defines how many chars can appear per frame. Use a value less than {@code 1} to disable this limit. Default value\n * is {@code -1}.\n */\n public static int CHAR_LIMIT_PER_FRAME = -1;\n\n /** Default color for the {@code CLEARCOLOR} token. Can be overriden by {@link TypingLabel#getClearColor()}. */\n public static Color DEFAULT_CLEAR_COLOR = new Color(Color.WHITE);\n\n /** Characters used to start and end tokens. Defaults to {@link TokenDelimiter#CURLY_BRACKETS}.*/\n public static TokenDelimiter TOKEN_DELIMITER = TokenDelimiter.CURLY_BRACKETS;\n\n /**\n * Returns a map of characters and their respective interval multipliers, of which the interval to the next char\n * should be multiplied for.\n */\n public static ObjectFloatMap INTERVAL_MULTIPLIERS_BY_CHAR = new ObjectFloatMap();\n\n /** Map of global variables that affect all {@link TypingLabel} instances at once. */\n public static final ObjectMap GLOBAL_VARS = new ObjectMap<>();\n\n /** Map of start tokens and their effect classes. Internal use only. */\n static final ObjectMap> EFFECT_START_TOKENS = new ObjectMap<>();\n\n /** Map of end tokens and their effect classes. Internal use only. */\n static final ObjectMap> EFFECT_END_TOKENS = new ObjectMap<>();\n\n /** Whether or not effect tokens are dirty and need to be recalculated. */\n static boolean dirtyEffectMaps = true;\n\n /**\n * Registers a new effect to TypingLabel.\n *\n * @param startTokenName Name of the token that starts the effect, such as WAVE.\n * @param endTokenName Name of the token that ends the effect, such as ENDWAVE.\n * @param effectClass Class of the effect, such as WaveEffect.class.\n */\n public static void registerEffect(String startTokenName, String endTokenName, Class effectClass) {\n EFFECT_START_TOKENS.put(startTokenName.toUpperCase(), effectClass);\n EFFECT_END_TOKENS.put(endTokenName.toUpperCase(), effectClass);\n dirtyEffectMaps = true;\n }\n\n /**\n * Unregisters an effect from TypingLabel.\n *\n * @param startTokenName Name of the token that starts the effect, such as WAVE.\n * @param endTokenName Name of the token that ends the effect, such as ENDWAVE.\n */\n public static void unregisterEffect(String startTokenName, String endTokenName) {\n EFFECT_START_TOKENS.remove(startTokenName.toUpperCase());\n EFFECT_END_TOKENS.remove(endTokenName.toUpperCase());\n }\n\n static {\n // Generate default char intervals\n INTERVAL_MULTIPLIERS_BY_CHAR.put(' ', 0.0f);\n INTERVAL_MULTIPLIERS_BY_CHAR.put(':', 1.5f);\n INTERVAL_MULTIPLIERS_BY_CHAR.put(',', 2.5f);\n INTERVAL_MULTIPLIERS_BY_CHAR.put('.', 2.5f);\n INTERVAL_MULTIPLIERS_BY_CHAR.put('!', 5.0f);\n INTERVAL_MULTIPLIERS_BY_CHAR.put('?', 5.0f);\n INTERVAL_MULTIPLIERS_BY_CHAR.put('\\n', 20f);\n\n // Register default tokens\n registerEffect(\"EASE\", \"ENDEASE\", EaseEffect.class);\n registerEffect(\"HANG\", \"ENDHANG\", HangEffect.class);\n registerEffect(\"JUMP\", \"ENDJUMP\", JumpEffect.class);\n registerEffect(\"SHAKE\", \"ENDSHAKE\", ShakeEffect.class);\n registerEffect(\"SICK\", \"ENDSICK\", SickEffect.class);\n registerEffect(\"SLIDE\", \"ENDSLIDE\", SlideEffect.class);\n registerEffect(\"WAVE\", \"ENDWAVE\", WaveEffect.class);\n registerEffect(\"WIND\", \"ENDWIND\", WindEffect.class);\n registerEffect(\"RAINBOW\", \"ENDRAINBOW\", RainbowEffect.class);\n registerEffect(\"GRADIENT\", \"ENDGRADIENT\", GradientEffect.class);\n registerEffect(\"FADE\", \"ENDFADE\", FadeEffect.class);\n registerEffect(\"BLINK\", \"ENDBLINK\", BlinkEffect.class);\n }\n\n}\n"
},
{
"path": "src/main/java/com/rafaskoberg/gdx/typinglabel/TypingGlyph.java",
"content": "package com.rafaskoberg.gdx.typinglabel;\n\nimport com.badlogic.gdx.graphics.Color;\nimport com.badlogic.gdx.graphics.g2d.BitmapFont.Glyph;\nimport com.badlogic.gdx.graphics.g2d.GlyphLayout;\nimport com.badlogic.gdx.graphics.g2d.GlyphLayout.GlyphRun;\n\n/** Extension of {@link Glyph} with additional data exposed to the user. */\npublic class TypingGlyph extends Glyph {\n\n /** The color of the run this glyph belongs to, as an ABGR8888 int. */\n public int runColor = 0xFFFFFFFF;\n\n /** Internal index associated with this glyph. Internal use only. Defaults to -1. */\n int internalIndex = -1;\n\n /** Color of this glyph. If set to null, the run's color will be used. Defaults to null. */\n public Color color = null;\n\n}\n"
},
{
"path": "src/main/java/com/rafaskoberg/gdx/typinglabel/TypingLabel.java",
"content": "\npackage com.rafaskoberg.gdx.typinglabel;\n\nimport com.badlogic.gdx.graphics.Color;\nimport com.badlogic.gdx.graphics.g2d.Batch;\nimport com.badlogic.gdx.graphics.g2d.BitmapFont;\nimport com.badlogic.gdx.graphics.g2d.BitmapFont.Glyph;\nimport com.badlogic.gdx.graphics.g2d.BitmapFontCache;\nimport com.badlogic.gdx.graphics.g2d.GlyphLayout;\nimport com.badlogic.gdx.graphics.g2d.GlyphLayout.GlyphRun;\nimport com.badlogic.gdx.math.MathUtils;\nimport com.badlogic.gdx.scenes.scene2d.ui.Label;\nimport com.badlogic.gdx.scenes.scene2d.ui.Skin;\nimport com.badlogic.gdx.scenes.scene2d.utils.Drawable;\nimport com.badlogic.gdx.utils.*;\nimport com.badlogic.gdx.utils.StringBuilder;\nimport com.badlogic.gdx.utils.ObjectMap.Entry;\nimport com.badlogic.gdx.utils.reflect.ClassReflection;\n\n/**\n * An extension of {@link Label} that progressively shows the text as if it was being typed in real time, and allows the\n * use of tokens in the following format: {TOKEN=PARAMETER}.\n */\npublic class TypingLabel extends Label {\n ///////////////////////\n /// --- Members --- ///\n ///////////////////////\n\n // Collections\n private final ObjectMap variables = new ObjectMap();\n protected final Array tokenEntries = new Array();\n\n // Config\n private Color clearColor = new Color(TypingConfig.DEFAULT_CLEAR_COLOR);\n private final Array listeners = new Array<>(TypingListener.class);\n boolean forceMarkupColor = TypingConfig.FORCE_COLOR_MARKUP_BY_DEFAULT;\n\n // Internal state\n private final StringBuilder originalText = new StringBuilder();\n private final Array glyphCache = new Array();\n private final IntArray glyphRunCapacities = new IntArray();\n private final IntArray offsetCache = new IntArray();\n private final IntArray layoutLineBreaks = new IntArray();\n private final Array activeEffects = new Array();\n private float textSpeed = TypingConfig.DEFAULT_SPEED_PER_CHAR;\n private float charCooldown = textSpeed;\n private int rawCharIndex = -2; // All chars, including color codes\n private int glyphCharIndex = -1; // Only renderable chars, excludes color codes\n private int glyphCharCompensation = 0;\n private int cachedGlyphCharIndex = -1; // Last glyphCharIndex sent to the cache\n private float lastLayoutX = 0;\n private float lastLayoutY = 0;\n private boolean parsed = false;\n private boolean paused = false;\n private boolean ended = false;\n private boolean skipping = false;\n private boolean ignoringEvents = false;\n private boolean ignoringEffects = false;\n private String defaultToken = \"\";\n\n // Superclass mirroring\n boolean wrap;\n String ellipsis;\n float lastPrefHeight;\n boolean fontScaleChanged = false;\n private static final Color tempColor = new Color();\n\n ////////////////////////////\n /// --- Constructors --- ///\n ////////////////////////////\n\n public TypingLabel(CharSequence text, LabelStyle style) {\n super(text, style);\n saveOriginalText();\n }\n\n public TypingLabel(CharSequence text, Skin skin, String fontName, Color color) {\n super(text, skin, fontName, color);\n saveOriginalText();\n }\n\n public TypingLabel(CharSequence text, Skin skin, String fontName, String colorName) {\n super(text, skin, fontName, colorName);\n saveOriginalText();\n }\n\n public TypingLabel(CharSequence text, Skin skin, String styleName) {\n super(text, skin, styleName);\n saveOriginalText();\n }\n\n public TypingLabel(CharSequence text, Skin skin) {\n super(text, skin);\n saveOriginalText();\n }\n\n /////////////////////////////\n /// --- Text Handling --- ///\n /////////////////////////////\n\n /**\n * Modifies the text of this label. If the char progression is already running, it's highly recommended to use\n * {@link #restart(CharSequence)} instead.\n */\n @Override\n public void setText(CharSequence newText) {\n this.setText(newText, true);\n }\n\n /**\n * Sets the text of this label.\n *\n * @param modifyOriginalText Flag determining if the original text should be modified as well. If {@code false},\n * only the display text is changed while the original text is untouched.\n * @see #restart(CharSequence)\n */\n protected void setText(CharSequence newText, boolean modifyOriginalText) {\n setText(newText, modifyOriginalText, true);\n }\n\n /**\n * Sets the text of this label.\n *\n * @param modifyOriginalText Flag determining if the original text should be modified as well. If {@code false},\n * only the display text is changed while the original text is untouched.\n * @param restart Whether or not this label should restart. Defaults to true.\n * @see #restart(CharSequence)\n */\n protected void setText(CharSequence newText, boolean modifyOriginalText, boolean restart) {\n final boolean hasEnded = this.hasEnded();\n super.setText(newText);\n if(modifyOriginalText) saveOriginalText();\n if(restart) {\n this.restart();\n }\n if(hasEnded) {\n this.skipToTheEnd(true, false);\n }\n }\n\n /** Similar to {@link #getText()}, but returns the original text with all the tokens unchanged. */\n public StringBuilder getOriginalText() {\n return originalText;\n }\n\n /**\n * Copies the content of {@link #getText()} to the {@link StringBuilder} containing the original text with all\n * tokens unchanged.\n */\n protected void saveOriginalText() {\n originalText.setLength(0);\n originalText.insert(0, this.getText());\n originalText.trimToSize();\n }\n\n /**\n * Restores the original text with all tokens unchanged to this label. Make sure to call {@link #parseTokens()} to\n * parse the tokens again.\n */\n protected void restoreOriginalText() {\n super.setText(originalText);\n this.parsed = false;\n }\n\n ////////////////////////////\n /// --- External API --- ///\n ////////////////////////////\n\n /** Returns the {@link TypingListener}s associated with this label. May be empty. */\n public Array getTypingListeners() {\n return listeners;\n }\n\n /** Adds a {@link TypingListener} to this label. */\n public void addTypingListener(TypingListener listener) {\n listeners.add(listener);\n }\n\n /** Clears all {@link TypingListener}s associated with this label. */\n public void clearTypingListeners() {\n listeners.clear();\n }\n\n /**\n * Returns a {@link Color} instance with the color to be used on {@code CLEARCOLOR} tokens. Modify this instance to\n * change the token color. Default value is specified by {@link TypingConfig}.\n *\n * @see TypingConfig#DEFAULT_CLEAR_COLOR\n */\n public Color getClearColor() {\n return clearColor;\n }\n\n /**\n * Sets whether or not this instance should enable markup color by force.\n *\n * @see TypingConfig#FORCE_COLOR_MARKUP_BY_DEFAULT\n */\n public void setForceMarkupColor(boolean forceMarkupColor) {\n this.forceMarkupColor = forceMarkupColor;\n }\n\n /** Returns the default token being used in this label. Defaults to empty string. */\n public String getDefaultToken() {\n return defaultToken;\n }\n\n /**\n * Sets the default token being used in this label. This token will be used before the label's text, and after each\n * {RESET} call. Useful if you want a certain token to be active at all times without having to type it all the\n * time.\n */\n public void setDefaultToken(String defaultToken) {\n this.defaultToken = defaultToken == null ? \"\" : defaultToken;\n this.parsed = false;\n }\n\n /** Parses all tokens of this label. Use this after setting the text and any variables that should be replaced. */\n public void parseTokens() {\n this.setText(getDefaultToken() + getText(), false, false);\n Parser.parseTokens(this);\n parsed = true;\n }\n\n /**\n * Skips the char progression to the end, showing the entire label. Useful for when users don't want to wait for too\n * long. Ignores all subsequent events by default.\n */\n public void skipToTheEnd() {\n skipToTheEnd(true);\n }\n\n /**\n * Skips the char progression to the end, showing the entire label. Useful for when users don't want to wait for too\n * long.\n *\n * @param ignoreEvents If {@code true}, skipped events won't be reported to the listener.\n */\n public void skipToTheEnd(boolean ignoreEvents) {\n skipToTheEnd(ignoreEvents, false);\n }\n\n /**\n * Skips the char progression to the end, showing the entire label. Useful for when users don't want to wait for too\n * long.\n *\n * @param ignoreEvents If {@code true}, skipped events won't be reported to the listener.\n * @param ignoreEffects If {@code true}, all text effects will be instantly cancelled.\n */\n public void skipToTheEnd(boolean ignoreEvents, boolean ignoreEffects) {\n skipping = true;\n ignoringEvents = ignoreEvents;\n ignoringEffects = ignoreEffects;\n }\n\n /**\n * Cancels calls to {@link #skipToTheEnd()}. Useful if you need to restore the label's normal behavior at some event\n * after skipping.\n */\n public void cancelSkipping() {\n if(skipping) {\n skipping = false;\n ignoringEvents = false;\n ignoringEffects = false;\n }\n }\n\n /**\n * Returns whether or not this label is currently skipping its typing progression all the way to the end. This is\n * only true if skipToTheEnd is called.\n */\n public boolean isSkipping() {\n return skipping;\n }\n\n /** Returns whether or not this label is paused. */\n public boolean isPaused() {\n return paused;\n }\n\n /** Pauses this label's character progression. */\n public void pause() {\n paused = true;\n }\n\n /** Resumes this label's character progression. */\n public void resume() {\n paused = false;\n }\n\n /** Returns whether or not this label's char progression has ended. */\n public boolean hasEnded() {\n return ended;\n }\n\n /**\n * Restarts this label with the original text and starts the char progression right away. All tokens are\n * automatically parsed.\n */\n public void restart() {\n restart(getOriginalText());\n }\n\n /**\n * Restarts this label with the given text and starts the char progression right away. All tokens are automatically\n * parsed.\n */\n public void restart(CharSequence newText) {\n // Reset cache collections\n GlyphUtils.freeAll(glyphCache);\n glyphCache.clear();\n glyphRunCapacities.clear();\n offsetCache.clear();\n layoutLineBreaks.clear();\n activeEffects.clear();\n\n // Reset state\n textSpeed = TypingConfig.DEFAULT_SPEED_PER_CHAR;\n charCooldown = textSpeed;\n rawCharIndex = -2;\n glyphCharIndex = -1;\n glyphCharCompensation = 0;\n cachedGlyphCharIndex = -1;\n lastLayoutX = 0;\n lastLayoutY = 0;\n parsed = false;\n paused = false;\n ended = false;\n skipping = false;\n ignoringEvents = false;\n ignoringEffects = false;\n\n // Set new text\n this.setText(newText, true, false);\n invalidate();\n\n // Parse tokens\n tokenEntries.clear();\n parseTokens();\n }\n\n /** Returns an {@link ObjectMap} with all the variable names and their respective replacement values. */\n public ObjectMap getVariables() {\n return variables;\n }\n\n /** Registers a variable and its respective replacement value to this label. */\n public void setVariable(String var, String value) {\n variables.put(var.toUpperCase(), value);\n }\n\n /** Registers a set of variables and their respective replacement values to this label. */\n public void setVariables(ObjectMap variableMap) {\n this.variables.clear();\n for(Entry entry : variableMap.entries()) {\n this.variables.put(entry.key.toUpperCase(), entry.value);\n }\n }\n\n /** Registers a set of variables and their respective replacement values to this label. */\n public void setVariables(java.util.Map variableMap) {\n this.variables.clear();\n for(java.util.Map.Entry entry : variableMap.entrySet()) {\n this.variables.put(entry.getKey().toUpperCase(), entry.getValue());\n }\n }\n\n /** Removes all variables from this label. */\n public void clearVariables() {\n this.variables.clear();\n }\n\n //////////////////////////////////\n /// --- Core Functionality --- ///\n //////////////////////////////////\n\n @Override\n public void act(float delta) {\n super.act(delta);\n\n // Force token parsing\n if(!parsed) {\n parseTokens();\n }\n\n // Update cooldown and process char progression\n if(skipping || (!ended && !paused)) {\n if(skipping || (charCooldown -= delta) < 0.0f) {\n processCharProgression();\n }\n }\n\n // Restore glyph offsets\n if(activeEffects.size > 0) {\n for(int i = 0; i < glyphCache.size; i++) {\n TypingGlyph glyph = glyphCache.get(i);\n glyph.xoffset = offsetCache.get(i * 2);\n glyph.yoffset = offsetCache.get(i * 2 + 1);\n }\n }\n\n // Apply effects\n if(!ignoringEffects) {\n for(int i = activeEffects.size - 1; i >= 0; i--) {\n Effect effect = activeEffects.get(i);\n effect.update(delta);\n int start = effect.indexStart;\n int end = effect.indexEnd >= 0 ? effect.indexEnd : glyphCharIndex;\n\n // If effect is finished, remove it\n if(effect.isFinished()) {\n activeEffects.removeIndex(i);\n continue;\n }\n\n // Apply effect to glyph\n for(int j = Math.max(0, start); j <= glyphCharIndex && j <= end && j < glyphCache.size; j++) {\n TypingGlyph glyph = glyphCache.get(j);\n effect.apply(glyph, j, delta);\n }\n }\n }\n }\n\n /** Proccess char progression according to current cooldown and process all tokens in the current index. */\n private void processCharProgression() {\n // Keep a counter of how many chars we're processing in this tick.\n int charCounter = 0;\n\n // Process chars while there's room for it\n while(skipping || charCooldown < 0.0f) {\n // Apply compensation to glyph index, if any\n if(glyphCharCompensation != 0) {\n if(glyphCharCompensation > 0) {\n glyphCharIndex++;\n glyphCharCompensation--;\n } else {\n glyphCharIndex--;\n glyphCharCompensation++;\n }\n\n // Increment cooldown and wait for it\n charCooldown += textSpeed;\n continue;\n }\n\n // Increase raw char index\n rawCharIndex++;\n\n // Get next character and calculate cooldown increment\n int safeIndex = MathUtils.clamp(rawCharIndex, 0, getText().length - 1);\n char primitiveChar = '\\u0000'; // Null character by default\n if(getText().length > 0) {\n primitiveChar = getText().charAt(safeIndex);\n float intervalMultiplier = TypingConfig.INTERVAL_MULTIPLIERS_BY_CHAR.get(primitiveChar, 1);\n charCooldown += textSpeed * intervalMultiplier;\n }\n\n // If char progression is finished, or if text is empty, notify listener and abort routine\n int textLen = getText().length;\n if(textLen == 0 || rawCharIndex >= textLen) {\n if(!ended) {\n ended = true;\n skipping = false;\n for(TypingListener listener : listeners) {\n listener.end();\n }\n }\n return;\n }\n\n // Detect layout line breaks\n boolean isLayoutLineBreak = false;\n if(layoutLineBreaks.contains(glyphCharIndex)) {\n layoutLineBreaks.removeValue(glyphCharIndex);\n isLayoutLineBreak = true;\n }\n\n // Increase glyph char index for all characters, except new lines.\n if(rawCharIndex >= 0 && primitiveChar != '\\n' && primitiveChar != '\\r' && !isLayoutLineBreak) glyphCharIndex++;\n\n // Process tokens according to the current index\n while(tokenEntries.size > 0 && tokenEntries.peek().index == rawCharIndex) {\n TokenEntry entry = tokenEntries.pop();\n String token = entry.token;\n TokenCategory category = entry.category;\n\n // Process tokens\n switch(category) {\n case SPEED: {\n textSpeed = entry.floatValue;\n continue;\n }\n case WAIT: {\n glyphCharIndex--;\n glyphCharCompensation++;\n charCooldown += entry.floatValue;\n continue;\n }\n case SKIP: {\n if(entry.stringValue != null) {\n rawCharIndex += entry.stringValue.length();\n }\n continue;\n }\n case EVENT: {\n if(!ignoringEvents) {\n for(TypingListener listener : listeners) {\n listener.event(entry.stringValue);\n }\n }\n continue;\n }\n case EFFECT_START:\n case EFFECT_END: {\n // Get effect class\n boolean isStart = category == TokenCategory.EFFECT_START;\n Class effectClass = isStart ? TypingConfig.EFFECT_START_TOKENS.get(token) : TypingConfig.EFFECT_END_TOKENS.get(token);\n\n // End all effects of the same type\n for(int i = 0; i < activeEffects.size; i++) {\n Effect effect = activeEffects.get(i);\n if(effect.indexEnd < 0) {\n if(ClassReflection.isAssignableFrom(effectClass, effect.getClass())) {\n effect.indexEnd = glyphCharIndex - 1;\n }\n }\n }\n\n // Create new effect if necessary\n if(isStart) {\n entry.effect.indexStart = glyphCharIndex;\n activeEffects.add(entry.effect);\n }\n\n }\n }\n }\n\n // Notify listener about char progression\n int nextIndex = MathUtils.clamp(rawCharIndex, 0, getText().length - 1);\n Character nextChar = nextIndex == 0 ? null : getText().charAt(nextIndex);\n if(nextChar != null) {\n for(TypingListener listener : listeners) {\n listener.onChar(nextChar);\n }\n }\n\n // Increment char counter\n charCounter++;\n\n // Break loop if this was our first glyph to prevent glyph issues.\n if(glyphCharIndex == -1) {\n charCooldown = textSpeed;\n break;\n }\n\n // Break loop if enough chars were processed\n charCounter++;\n int charLimit = TypingConfig.CHAR_LIMIT_PER_FRAME;\n if(!skipping && charLimit > 0 && charCounter > charLimit) {\n charCooldown = Math.max(charCooldown, textSpeed);\n break;\n }\n }\n }\n\n @Override\n public boolean remove() {\n GlyphUtils.freeAll(glyphCache);\n glyphCache.clear();\n return super.remove();\n }\n\n ////////////////////////////////////\n /// --- Superclass Mirroring --- ///\n ////////////////////////////////////\n\n @Override\n public BitmapFontCache getBitmapFontCache() {\n return super.getBitmapFontCache();\n }\n\n @Override\n public void setEllipsis(String ellipsis) {\n // Mimics superclass but keeps an accessible reference\n super.setEllipsis(ellipsis);\n this.ellipsis = ellipsis;\n }\n\n @Override\n public void setEllipsis(boolean ellipsis) {\n // Mimics superclass but keeps an accessible reference\n super.setEllipsis(ellipsis);\n if(ellipsis)\n this.ellipsis = \"...\";\n else\n this.ellipsis = null;\n }\n\n @Override\n public void setWrap(boolean wrap) {\n // Mimics superclass but keeps an accessible reference\n super.setWrap(wrap);\n this.wrap = wrap;\n }\n\n @Override\n public void setFontScale(float fontScale) {\n super.setFontScale(fontScale);\n this.fontScaleChanged = true;\n }\n\n @Override\n public void setFontScale(float fontScaleX, float fontScaleY) {\n super.setFontScale(fontScaleX, fontScaleY);\n this.fontScaleChanged = true;\n }\n\n @Override\n public void setFontScaleX(float fontScaleX) {\n super.setFontScaleX(fontScaleX);\n this.fontScaleChanged = true;\n }\n\n @Override\n public void setFontScaleY(float fontScaleY) {\n super.setFontScaleY(fontScaleY);\n this.fontScaleChanged = true;\n }\n\n @Override\n public void layout() {\n // --- SUPERCLASS IMPLEMENTATION ---\n BitmapFontCache cache = getBitmapFontCache();\n StringBuilder text = getText();\n GlyphLayout layout = super.getGlyphLayout();\n int lineAlign = getLineAlign();\n int labelAlign = getLabelAlign();\n LabelStyle style = getStyle();\n\n BitmapFont font = cache.getFont();\n float oldScaleX = font.getScaleX();\n float oldScaleY = font.getScaleY();\n if(fontScaleChanged) font.getData().setScale(getFontScaleX(), getFontScaleY());\n\n boolean wrap = this.wrap && ellipsis == null;\n if(wrap) {\n float prefHeight = getPrefHeight();\n if(prefHeight != lastPrefHeight) {\n lastPrefHeight = prefHeight;\n invalidateHierarchy();\n }\n }\n\n float width = getWidth(), height = getHeight();\n Drawable background = style.background;\n float x = 0, y = 0;\n if(background != null) {\n x = background.getLeftWidth();\n y = background.getBottomHeight();\n width -= background.getLeftWidth() + background.getRightWidth();\n height -= background.getBottomHeight() + background.getTopHeight();\n }\n\n float textWidth, textHeight;\n if(wrap || text.indexOf(\"\\n\") != -1) {\n // If the text can span multiple lines, determine the text's actual size so it can be aligned within the label.\n layout.setText(font, text, 0, text.length, Color.WHITE, width, lineAlign, wrap, ellipsis);\n textWidth = layout.width;\n textHeight = layout.height;\n\n if((labelAlign & Align.left) == 0) {\n if((labelAlign & Align.right) != 0)\n x += width - textWidth;\n else\n x += (width - textWidth) / 2;\n }\n } else {\n textWidth = width;\n textHeight = font.getData().capHeight;\n }\n\n if((labelAlign & Align.top) != 0) {\n y += cache.getFont().isFlipped() ? 0 : height - textHeight;\n y += style.font.getDescent();\n } else if((labelAlign & Align.bottom) != 0) {\n y += cache.getFont().isFlipped() ? height - textHeight : 0;\n y -= style.font.getDescent();\n } else {\n y += (height - textHeight) / 2;\n }\n if(!cache.getFont().isFlipped()) y += textHeight;\n\n layout.setText(font, text, 0, text.length, Color.WHITE, textWidth, lineAlign, wrap, ellipsis);\n cache.setText(layout, x, y);\n\n if(fontScaleChanged) font.getData().setScale(oldScaleX, oldScaleY);\n\n // --- END OF SUPERCLASS IMPLEMENTATION ---\n\n // Store coordinates passed to BitmapFontCache\n lastLayoutX = x;\n lastLayoutY = y;\n\n // Perform cache layout operation, where the magic happens\n GlyphUtils.freeAll(glyphCache);\n glyphCache.clear();\n layoutCache();\n }\n\n /**\n * Reallocate glyph clones according to the updated {@link GlyphLayout}. This should only be called when the text or\n * the layout changes.\n */\n private void layoutCache() {\n BitmapFontCache cache = getBitmapFontCache();\n GlyphLayout layout = super.getGlyphLayout();\n Array runs = layout.runs;\n IntArray colors = layout.colors;\n\n // Reset layout line breaks\n layoutLineBreaks.clear();\n\n // Store GlyphRun sizes and count how many glyphs we have\n int glyphCount = 0;\n glyphRunCapacities.setSize(runs.size);\n for(int i = 0; i < runs.size; i++) {\n Array glyphs = runs.get(i).glyphs;\n glyphRunCapacities.set(i, glyphs.size);\n glyphCount += glyphs.size;\n }\n\n // Make sure our cache array can hold all glyphs\n if(glyphCache.size < glyphCount) {\n glyphCache.setSize(glyphCount);\n offsetCache.setSize(glyphCount * 2);\n }\n\n // Clone original glyphs with independent instances\n int index = -1;\n float lastY = 0;\n\n int colorIndex = 1;\n int currentColor = colors.size < 2 ? 0xFFFFFFFF : colors.get(1);\n int colorChange = colors.size < 4 ? glyphCount : colors.get(2);\n\n for(int i = 0; i < runs.size; i++) {\n GlyphRun run = runs.get(i);\n Array glyphs = run.glyphs;\n for(int j = 0; j < glyphs.size; j++) {\n\n // Detect and store layout line breaks\n if(!MathUtils.isEqual(run.y, lastY)) {\n lastY = run.y;\n layoutLineBreaks.add(index);\n }\n\n // Increment index\n index++;\n if(index >= colorChange && colorIndex + 2 < colors.size)\n {\n currentColor = colors.get(colorIndex += 2);\n colorChange = colors.size <= colorIndex + 1 ? glyphCount : colors.get(colorIndex + 1);\n }\n\n // Get original glyph\n Glyph original = glyphs.get(j);\n\n // Get clone glyph\n TypingGlyph clone = null;\n if(index < glyphCache.size) {\n clone = glyphCache.get(index);\n }\n if(clone == null) {\n clone = GlyphUtils.obtain();\n glyphCache.set(index, clone);\n }\n GlyphUtils.clone(original, clone);\n clone.width *= getFontScaleX();\n clone.height *= getFontScaleY();\n clone.xoffset *= getFontScaleX();\n clone.yoffset *= getFontScaleY();\n clone.runColor = currentColor;\n\n // Store offset data\n offsetCache.set(index * 2, clone.xoffset);\n offsetCache.set(index * 2 + 1, clone.yoffset);\n\n // Replace glyph in original array\n glyphs.set(j, clone);\n }\n }\n\n // Remove exceeding glyphs from original array\n int glyphCountdown = glyphCharIndex;\n for(int i = 0; i < runs.size; i++) {\n Array glyphs = runs.get(i).glyphs;\n if(glyphs.size < glyphCountdown) {\n glyphCountdown -= glyphs.size;\n continue;\n }\n\n for(int j = 0; j < glyphs.size; j++) {\n if(glyphCountdown < 0) {\n glyphs.removeRange(j, glyphs.size - 1);\n break;\n }\n glyphCountdown--;\n }\n }\n\n // Pass new layout with custom glyphs to BitmapFontCache\n cache.setText(layout, lastLayoutX, lastLayoutY);\n }\n\n /** Adds cached glyphs to the active BitmapFontCache as the char index progresses. */\n private void addMissingGlyphs() {\n // Add additional glyphs to layout array, if any\n int glyphLeft = glyphCharIndex - cachedGlyphCharIndex;\n if(glyphLeft < 1) return;\n\n // Get runs\n GlyphLayout layout = super.getGlyphLayout();\n Array runs = layout.runs;\n\n // Iterate through GlyphRuns to find the next glyph spot\n int glyphCount = 0;\n for(int runIndex = 0; runIndex < glyphRunCapacities.size; runIndex++) {\n int runCapacity = glyphRunCapacities.get(runIndex);\n if((glyphCount + runCapacity) < cachedGlyphCharIndex) {\n glyphCount += runCapacity;\n continue;\n }\n\n // Get run and increase glyphCount up to its current size\n Array glyphs = runs.get(runIndex).glyphs;\n glyphCount += glyphs.size;\n\n // Next glyphs go here\n while(glyphLeft > 0) {\n\n // Skip run if this one is full\n int runSize = glyphs.size;\n if(runCapacity == runSize) {\n break;\n }\n\n // Put new glyph to this run\n cachedGlyphCharIndex++;\n TypingGlyph glyph = glyphCache.get(cachedGlyphCharIndex);\n glyphs.add(glyph);\n\n // Cache glyph's vertex index\n glyph.internalIndex = glyphCount;\n\n // Advance glyph count\n glyphCount++;\n glyphLeft--;\n }\n }\n }\n\n @Override\n public void draw(Batch batch, float parentAlpha) {\n super.validate();\n addMissingGlyphs();\n\n // Update cache with new glyphs\n BitmapFontCache bitmapFontCache = getBitmapFontCache();\n getBitmapFontCache().setText(getGlyphLayout(), lastLayoutX, lastLayoutY);\n\n // --- SUPERCLASS IMPLEMENTATION ---\n // This section has to be copied from Label, since we can't call super.draw() without messing up our color.\n validate();\n Color color = tempColor.set(getColor());\n color.a *= parentAlpha;\n if (getStyle().background != null) {\n batch.setColor(color.r, color.g, color.b, color.a);\n getStyle().background.draw(batch, getX(), getY(), getWidth(), getHeight());\n }\n if (getStyle().fontColor != null) color.mul(getStyle().fontColor);\n // --- END OF SUPERCLASS IMPLEMENTATION ---\n\n // Here we store color as its components, to avoid producing garbage and to allow modifying the local color.\n float r = color.r, g = color.g, b = color.b, a = color.a;\n for(TypingGlyph glyph : glyphCache) {\n if (glyph.internalIndex >= 0) {\n if (glyph.color != null) {\n // Unless we want to use a packed float, it's easiest to pass a Color object here, multiplying this\n // Label color (as its components) by the color of the individual glyph.\n bitmapFontCache.setColors(\n Color.toFloatBits(r * glyph.color.r, g * glyph.color.g, b * glyph.color.b, a * glyph.color.a),\n glyph.internalIndex, glyph.internalIndex + 1);\n } else if(a < 1f) {\n bitmapFontCache.setColors(color, glyph.internalIndex, glyph.internalIndex + 1);\n }\n }\n }\n\n // --- SUPERCLASS IMPLEMENTATION ---\n // This also replicates Label. Note that we don't call the super-method.\n bitmapFontCache.setPosition(getX(), getY());\n bitmapFontCache.draw(batch);\n // --- END OF SUPERCLASS IMPLEMENTATION ---\n }\n\n}\n"
},
{
"path": "src/main/java/com/rafaskoberg/gdx/typinglabel/TypingListener.java",
"content": "\npackage com.rafaskoberg.gdx.typinglabel;\n\n/** Simple listener for label events. */\npublic interface TypingListener {\n\n /**\n * Called each time an {@code EVENT} token is processed.\n *\n * @param event Name of the event specified in the token. e.g. {EVENT=player_name} will have\n * player_name as argument.\n */\n public void event(String event);\n\n /** Called when the char progression reaches the end. */\n public void end();\n\n /**\n * Called when variable tokens are replaced in text. This is an alternative method to deal with variables, other\n * than directly assigning replacement values to the label. Replacements returned by this method have priority over\n * direct values, unless {@code null} is returned.\n *\n * @param variable The variable name assigned to the {VAR} token. For example, in {VAR=townName},\n * the variable will be townName\n * @return The replacement String, or {@code null} if this method should be ignored and the regular values should be\n * used instead.\n * @see TypingLabel#setVariable(String, String)\n * @see TypingLabel#setVariables(java.util.Map)\n * @see TypingLabel#setVariables(com.badlogic.gdx.utils.ObjectMap)\n */\n public String replaceVariable(String variable);\n\n /**\n * Called when a new character is displayed. May be called many times per frame depending on the label\n * configurations and text speed. Useful to do a certain action each time a character is displayed, like playing a\n * sound effect.\n */\n public void onChar(Character ch);\n\n}\n"
},
{
"path": "src/main/java/com/rafaskoberg/gdx/typinglabel/effects/BlinkEffect.java",
"content": "\npackage com.rafaskoberg.gdx.typinglabel.effects;\n\nimport com.badlogic.gdx.graphics.Color;\nimport com.badlogic.gdx.math.MathUtils;\nimport com.rafaskoberg.gdx.typinglabel.Effect;\nimport com.rafaskoberg.gdx.typinglabel.TypingGlyph;\nimport com.rafaskoberg.gdx.typinglabel.TypingLabel;\n\n/** Blinks the entire text in two different colors at once, without interpolation. */\npublic class BlinkEffect extends Effect {\n private static final float DEFAULT_FREQUENCY = 1f;\n\n private Color color1 = null; // First color of the effect.\n private Color color2 = null; // Second color of the effect.\n private float frequency = 1; // How frequently the color pattern should move through the text.\n private float threshold = 0.5f; // Point to switch colors.\n\n public BlinkEffect(TypingLabel label, String[] params) {\n super(label);\n\n // Color 1\n if(params.length > 0) {\n this.color1 = paramAsColor(params[0]);\n }\n\n // Color 2\n if(params.length > 1) {\n this.color2 = paramAsColor(params[1]);\n }\n\n // Frequency\n if(params.length > 2) {\n this.frequency = paramAsFloat(params[2], 1);\n }\n\n // Threshold\n if(params.length > 3) {\n this.threshold = paramAsFloat(params[3], 0.5f);\n }\n\n // Validate parameters\n if(this.color1 == null) this.color1 = new Color(Color.WHITE);\n if(this.color2 == null) this.color2 = new Color(Color.WHITE);\n this.threshold = MathUtils.clamp(this.threshold, 0, 1);\n }\n\n @Override\n protected void onApply(TypingGlyph glyph, int localIndex, float delta) {\n // Calculate progress\n float frequencyMod = (1f / frequency) * DEFAULT_FREQUENCY;\n float progress = calculateProgress(frequencyMod);\n\n // Calculate color\n if(glyph.color == null) glyph.color = new Color(Color.WHITE);\n glyph.color.set(progress <= threshold ? color1 : color2);\n }\n\n}\n"
},
{
"path": "src/main/java/com/rafaskoberg/gdx/typinglabel/effects/EaseEffect.java",
"content": "\npackage com.rafaskoberg.gdx.typinglabel.effects;\n\nimport com.badlogic.gdx.math.Interpolation;\nimport com.badlogic.gdx.math.MathUtils;\nimport com.badlogic.gdx.utils.IntFloatMap;\nimport com.rafaskoberg.gdx.typinglabel.Effect;\nimport com.rafaskoberg.gdx.typinglabel.TypingGlyph;\nimport com.rafaskoberg.gdx.typinglabel.TypingLabel;\n\n/** Moves the text vertically easing it into the final position. Doesn't repeat itself. */\npublic class EaseEffect extends Effect {\n private static final float DEFAULT_DISTANCE = 0.15f;\n private static final float DEFAULT_INTENSITY = 0.075f;\n\n private float distance = 1; // How much of their height they should move\n private float intensity = 1; // How fast the glyphs should move\n private boolean elastic = false; // Whether or not the glyphs have an elastic movement\n\n private IntFloatMap timePassedByGlyphIndex = new IntFloatMap();\n\n public EaseEffect(TypingLabel label, String[] params) {\n super(label);\n\n // Distance\n if(params.length > 0) {\n this.distance = paramAsFloat(params[0], 1);\n }\n\n //Intensity\n if(params.length > 1) {\n this.intensity = paramAsFloat(params[1], 1);\n }\n\n // Elastic\n if(params.length > 2) {\n this.elastic = paramAsBoolean(params[2]);\n }\n }\n\n @Override\n protected void onApply(TypingGlyph glyph, int localIndex, float delta) {\n // Calculate real intensity\n float realIntensity = intensity * (elastic ? 3f : 1f) * DEFAULT_INTENSITY;\n\n // Calculate progress\n float timePassed = timePassedByGlyphIndex.getAndIncrement(localIndex, 0, delta);\n float progress = MathUtils.clamp(timePassed / realIntensity, 0, 1);\n\n // Calculate offset\n Interpolation interpolation = elastic ? Interpolation.swingOut : Interpolation.sine;\n float interpolatedValue = interpolation.apply(1, 0, progress);\n float y = getLineHeight() * distance * interpolatedValue * DEFAULT_DISTANCE;\n\n // Apply changes\n glyph.yoffset += y;\n }\n\n}\n"
},
{
"path": "src/main/java/com/rafaskoberg/gdx/typinglabel/effects/FadeEffect.java",
"content": "\npackage com.rafaskoberg.gdx.typinglabel.effects;\n\nimport com.badlogic.gdx.graphics.Color;\nimport com.badlogic.gdx.math.MathUtils;\nimport com.badlogic.gdx.utils.IntFloatMap;\nimport com.rafaskoberg.gdx.typinglabel.Effect;\nimport com.rafaskoberg.gdx.typinglabel.TypingGlyph;\nimport com.rafaskoberg.gdx.typinglabel.TypingLabel;\n\n/** Fades the text's color from between colors or alphas. Doesn't repeat itself. */\npublic class FadeEffect extends Effect {\n private Color color1 = null; // First color of the effect.\n private Color color2 = null; // Second color of the effect.\n private float alpha1 = 0; // First alpha of the effect, in case a color isn't provided.\n private float alpha2 = 1; // Second alpha of the effect, in case a color isn't provided.\n private float fadeDuration = 1; // Duration of the fade effect\n\n private IntFloatMap timePassedByGlyphIndex = new IntFloatMap();\n\n public FadeEffect(TypingLabel label, String[] params) {\n super(label);\n\n // Color 1 or Alpha 1\n if(params.length > 0) {\n this.color1 = paramAsColor(params[0]);\n if(this.color1 == null) {\n alpha1 = paramAsFloat(params[0], 0);\n }\n }\n\n // Color 2 or Alpha 2\n if(params.length > 1) {\n this.color2 = paramAsColor(params[1]);\n if(this.color2 == null) {\n alpha2 = paramAsFloat(params[1], 1);\n }\n }\n\n // Fade duration\n if(params.length > 2) {\n this.fadeDuration = paramAsFloat(params[2], 1);\n }\n }\n\n @Override\n protected void onApply(TypingGlyph glyph, int localIndex, float delta) {\n // Calculate progress\n float timePassed = timePassedByGlyphIndex.getAndIncrement(localIndex, 0, delta);\n float progress = MathUtils.clamp(timePassed / fadeDuration, 0, 1);\n\n // Create glyph color if necessary\n if(glyph.color == null) {\n glyph.color = new Color(Integer.reverseBytes(glyph.runColor));\n }\n\n // Calculate initial color\n if(this.color1 == null) {\n glyph.color.a = MathUtils.lerp(glyph.color.a, this.alpha1, 1f - progress);\n } else {\n glyph.color.lerp(this.color1, 1f - progress);\n }\n\n // Calculate final color\n if(this.color2 == null) {\n glyph.color.a = MathUtils.lerp(glyph.color.a, this.alpha2, progress);\n } else {\n glyph.color.lerp(this.color2, progress);\n }\n }\n\n}\n"
},
{
"path": "src/main/java/com/rafaskoberg/gdx/typinglabel/effects/GradientEffect.java",
"content": "\npackage com.rafaskoberg.gdx.typinglabel.effects;\n\nimport com.badlogic.gdx.graphics.Color;\nimport com.rafaskoberg.gdx.typinglabel.Effect;\nimport com.rafaskoberg.gdx.typinglabel.TypingGlyph;\nimport com.rafaskoberg.gdx.typinglabel.TypingLabel;\n\n/** Tints the text in a gradient pattern. */\npublic class GradientEffect extends Effect {\n private static final float DEFAULT_DISTANCE = 0.975f;\n private static final float DEFAULT_FREQUENCY = 2f;\n\n private Color color1 = null; // First color of the gradient.\n private Color color2 = null; // Second color of the gradient.\n private float distance = 1; // How extensive the rainbow effect should be.\n private float frequency = 1; // How frequently the color pattern should move through the text.\n\n public GradientEffect(TypingLabel label, String[] params) {\n super(label);\n\n // Color 1\n if(params.length > 0) {\n this.color1 = paramAsColor(params[0]);\n }\n\n // Color 2\n if(params.length > 1) {\n this.color2 = paramAsColor(params[1]);\n }\n\n // Distance\n if(params.length > 2) {\n this.distance = paramAsFloat(params[2], 1);\n }\n\n // Frequency\n if(params.length > 3) {\n this.frequency = paramAsFloat(params[3], 1);\n }\n\n // Validate parameters\n if(this.color1 == null) this.color1 = new Color(Color.WHITE);\n if(this.color2 == null) this.color2 = new Color(Color.WHITE);\n }\n\n @Override\n protected void onApply(TypingGlyph glyph, int localIndex, float delta) {\n // Calculate progress\n float distanceMod = (1f / distance) * (1f - DEFAULT_DISTANCE);\n float frequencyMod = (1f / frequency) * DEFAULT_FREQUENCY;\n float progress = calculateProgress(frequencyMod, distanceMod * localIndex, true);\n\n // Calculate color\n if(glyph.color == null) glyph.color = new Color(Color.WHITE);\n glyph.color.set(color1).lerp(color2, progress);\n }\n\n}\n"
},
{
"path": "src/main/java/com/rafaskoberg/gdx/typinglabel/effects/HangEffect.java",
"content": "\npackage com.rafaskoberg.gdx.typinglabel.effects;\n\nimport com.badlogic.gdx.math.Interpolation;\nimport com.badlogic.gdx.math.MathUtils;\nimport com.badlogic.gdx.utils.IntFloatMap;\nimport com.rafaskoberg.gdx.typinglabel.Effect;\nimport com.rafaskoberg.gdx.typinglabel.TypingGlyph;\nimport com.rafaskoberg.gdx.typinglabel.TypingLabel;\n\n/** Hangs the text in midair and suddenly drops it. Doesn't repeat itself. */\npublic class HangEffect extends Effect {\n private static final float DEFAULT_DISTANCE = 0.7f;\n private static final float DEFAULT_INTENSITY = 1.5f;\n\n private float distance = 1; // How much of their height they should move\n private float intensity = 1; // How fast the glyphs should move\n\n private IntFloatMap timePassedByGlyphIndex = new IntFloatMap();\n\n public HangEffect(TypingLabel label, String[] params) {\n super(label);\n\n // Distance\n if(params.length > 0) {\n this.distance = paramAsFloat(params[0], 1);\n }\n\n // Intensity\n if(params.length > 1) {\n this.intensity = paramAsFloat(params[1], 1);\n }\n }\n\n @Override\n protected void onApply(TypingGlyph glyph, int localIndex, float delta) {\n // Calculate real intensity\n float realIntensity = intensity * 1f * DEFAULT_INTENSITY;\n\n // Calculate progress\n float timePassed = timePassedByGlyphIndex.getAndIncrement(localIndex, 0, delta);\n float progress = MathUtils.clamp(timePassed / realIntensity, 0, 1);\n\n // Calculate offset\n float interpolation;\n float split = 0.7f;\n if(progress < split) {\n interpolation = Interpolation.pow3Out.apply(0, 1, progress / split);\n } else {\n interpolation = Interpolation.swing.apply(1, 0, (progress - split) / (1f - split));\n }\n float distanceFactor = Interpolation.linear.apply(1.0f, 1.5f, progress);\n float y = getLineHeight() * distance * distanceFactor * interpolation * DEFAULT_DISTANCE;\n\n // Calculate fadeout\n float fadeout = calculateFadeout();\n y *= fadeout;\n\n // Apply changes\n glyph.yoffset += y;\n }\n\n}\n"
},
{
"path": "src/main/java/com/rafaskoberg/gdx/typinglabel/effects/JumpEffect.java",
"content": "\npackage com.rafaskoberg.gdx.typinglabel.effects;\n\nimport com.badlogic.gdx.graphics.g2d.BitmapFont.Glyph;\nimport com.badlogic.gdx.math.Interpolation;\nimport com.rafaskoberg.gdx.typinglabel.Effect;\nimport com.rafaskoberg.gdx.typinglabel.TypingGlyph;\nimport com.rafaskoberg.gdx.typinglabel.TypingLabel;\n\n/** Makes the text jumps and falls as if there was gravity. */\npublic class JumpEffect extends Effect {\n private static final float DEFAULT_FREQUENCY = 50f;\n private static final float DEFAULT_DISTANCE = 1.33f;\n private static final float DEFAULT_INTENSITY = 1f;\n\n private float distance = 1; // How much of their height they should move\n private float frequency = 1; // How frequently the wave pattern repeats\n private float intensity = 1; // How fast the glyphs should move\n\n public JumpEffect(TypingLabel label, String[] params) {\n super(label);\n\n // Distance\n if(params.length > 0) {\n this.distance = paramAsFloat(params[0], 1);\n }\n\n // Frequency\n if(params.length > 1) {\n this.frequency = paramAsFloat(params[1], 1);\n }\n\n // Intensity\n if(params.length > 2) {\n this.intensity = paramAsFloat(params[2], 1);\n }\n\n // Duration\n if(params.length > 3) {\n this.duration = paramAsFloat(params[3], -1);\n }\n }\n\n @Override\n protected void onApply(TypingGlyph glyph, int localIndex, float delta) {\n // Calculate progress\n float progressModifier = (1f / intensity) * DEFAULT_INTENSITY;\n float normalFrequency = (1f / frequency) * DEFAULT_FREQUENCY;\n float progressOffset = localIndex / normalFrequency;\n float progress = calculateProgress(progressModifier, -progressOffset, false);\n\n // Calculate offset\n float interpolation = 0;\n float split = 0.2f;\n if(progress < split) {\n interpolation = Interpolation.pow2Out.apply(0, 1, progress / split);\n } else {\n interpolation = Interpolation.bounceOut.apply(1, 0, (progress - split) / (1f - split));\n }\n float y = getLineHeight() * distance * interpolation * DEFAULT_DISTANCE;\n\n // Calculate fadeout\n float fadeout = calculateFadeout();\n y *= fadeout;\n\n // Apply changes\n glyph.yoffset += y;\n }\n\n}\n"
},
{
"path": "src/main/java/com/rafaskoberg/gdx/typinglabel/effects/RainbowEffect.java",
"content": "\npackage com.rafaskoberg.gdx.typinglabel.effects;\n\nimport com.badlogic.gdx.graphics.Color;\nimport com.rafaskoberg.gdx.typinglabel.Effect;\nimport com.rafaskoberg.gdx.typinglabel.TypingGlyph;\nimport com.rafaskoberg.gdx.typinglabel.TypingLabel;\nimport com.rafaskoberg.gdx.typinglabel.utils.ColorUtils;\n\n/** Tints the text in a rainbow pattern. */\npublic class RainbowEffect extends Effect {\n private static final float DEFAULT_DISTANCE = 0.975f;\n private static final float DEFAULT_FREQUENCY = 2f;\n\n private float distance = 1; // How extensive the rainbow effect should be.\n private float frequency = 1; // How frequently the color pattern should move through the text.\n private float saturation = 1; // Color saturation\n private float brightness = 1; // Color brightness\n\n public RainbowEffect(TypingLabel label, String[] params) {\n super(label);\n\n // Distance\n if(params.length > 0) {\n this.distance = paramAsFloat(params[0], 1);\n }\n\n // Frequency\n if(params.length > 1) {\n this.frequency = paramAsFloat(params[1], 1);\n }\n\n // Saturation\n if(params.length > 2) {\n this.saturation = paramAsFloat(params[2], 1);\n }\n\n // Brightness\n if(params.length > 3) {\n this.brightness = paramAsFloat(params[3], 1);\n }\n }\n\n @Override\n protected void onApply(TypingGlyph glyph, int localIndex, float delta) {\n // Calculate progress\n float distanceMod = (1f / distance) * (1f - DEFAULT_DISTANCE);\n float frequencyMod = (1f / frequency) * DEFAULT_FREQUENCY;\n float progress = calculateProgress(frequencyMod, distanceMod * localIndex, false);\n\n // Calculate color\n if(glyph.color == null) {\n glyph.color = new Color(Color.WHITE);\n }\n ColorUtils.HSVtoRGB(360f * progress, saturation * 100f, brightness * 100f, glyph.color);\n }\n\n}\n"
},
{
"path": "src/main/java/com/rafaskoberg/gdx/typinglabel/effects/ShakeEffect.java",
"content": "\npackage com.rafaskoberg.gdx.typinglabel.effects;\n\nimport com.badlogic.gdx.graphics.g2d.BitmapFont.Glyph;\nimport com.badlogic.gdx.math.Interpolation;\nimport com.badlogic.gdx.math.MathUtils;\nimport com.badlogic.gdx.utils.FloatArray;\nimport com.rafaskoberg.gdx.typinglabel.Effect;\nimport com.rafaskoberg.gdx.typinglabel.TypingGlyph;\nimport com.rafaskoberg.gdx.typinglabel.TypingLabel;\n\n/** Shakes the text in a random pattern. */\npublic class ShakeEffect extends Effect {\n private static final float DEFAULT_DISTANCE = 0.12f;\n private static final float DEFAULT_INTENSITY = 0.5f;\n\n private final FloatArray lastOffsets = new FloatArray();\n\n private float distance = 1; // How far the glyphs should move\n private float intensity = 1; // How fast the glyphs should move\n\n public ShakeEffect(TypingLabel label, String[] params) {\n super(label);\n\n // Distance\n if(params.length > 0) {\n this.distance = paramAsFloat(params[0], 1);\n }\n\n // Intensity\n if(params.length > 1) {\n this.intensity = paramAsFloat(params[1], 1);\n }\n\n // Duration\n if(params.length > 2) {\n this.duration = paramAsFloat(params[2], -1);\n }\n }\n\n @Override\n protected void onApply(TypingGlyph glyph, int localIndex, float delta) {\n // Make sure we can hold enough entries for the current index\n if(localIndex >= lastOffsets.size / 2) {\n lastOffsets.setSize(lastOffsets.size + 16);\n }\n\n // Get last offsets\n float lastX = lastOffsets.get(localIndex * 2);\n float lastY = lastOffsets.get(localIndex * 2 + 1);\n\n // Calculate new offsets\n float x = getLineHeight() * distance * MathUtils.random(-1, 1) * DEFAULT_DISTANCE;\n float y = getLineHeight() * distance * MathUtils.random(-1, 1) * DEFAULT_DISTANCE;\n\n // Apply intensity\n float normalIntensity = MathUtils.clamp(intensity * DEFAULT_INTENSITY, 0, 1);\n x = Interpolation.linear.apply(lastX, x, normalIntensity);\n y = Interpolation.linear.apply(lastY, y, normalIntensity);\n\n // Apply fadeout\n float fadeout = calculateFadeout();\n x *= fadeout;\n y *= fadeout;\n x = Math.round(x);\n y = Math.round(y);\n\n // Store offsets for the next tick\n lastOffsets.set(localIndex * 2, x);\n lastOffsets.set(localIndex * 2 + 1, y);\n\n // Apply changes\n glyph.xoffset += x;\n glyph.yoffset += y;\n }\n\n}\n"
},
{
"path": "src/main/java/com/rafaskoberg/gdx/typinglabel/effects/SickEffect.java",
"content": "\npackage com.rafaskoberg.gdx.typinglabel.effects;\n\nimport com.badlogic.gdx.graphics.g2d.BitmapFont.Glyph;\nimport com.badlogic.gdx.math.Interpolation;\nimport com.badlogic.gdx.utils.IntArray;\nimport com.rafaskoberg.gdx.typinglabel.Effect;\nimport com.rafaskoberg.gdx.typinglabel.TypingGlyph;\nimport com.rafaskoberg.gdx.typinglabel.TypingLabel;\n\n/** Drips the text in a random pattern. */\npublic class SickEffect extends Effect {\n private static final float DEFAULT_FREQUENCY = 50f;\n private static final float DEFAULT_DISTANCE = .125f;\n private static final float DEFAULT_INTENSITY = 1f;\n\n public float distance = 1; // How far the glyphs should move\n public float intensity = 1; // How fast the glyphs should move\n\n private IntArray indices = new IntArray();\n\n public SickEffect(TypingLabel label, String[] params) {\n super(label);\n\n // Distance\n if(params.length > 0) {\n this.distance = paramAsFloat(params[0], 1);\n }\n\n // Intensity\n if(params.length > 1) {\n this.intensity = paramAsFloat(params[1], 1);\n }\n\n // Duration\n if(params.length > 2) {\n this.duration = paramAsFloat(params[2], -1);\n }\n }\n\n @Override\n protected void onApply(TypingGlyph glyph, int localIndex, float delta) {\n // Calculate progress\n float progressModifier = (1f / intensity) * DEFAULT_INTENSITY;\n float progressOffset = localIndex / DEFAULT_FREQUENCY;\n float progress = calculateProgress(progressModifier, -progressOffset, false);\n\n if(progress < .01f && Math.random() > .25f && !indices.contains(localIndex))\n indices.add(localIndex);\n if(progress > .95f)\n indices.removeValue(localIndex);\n\n if(!indices.contains(localIndex) &&\n !indices.contains(localIndex - 1) &&\n !indices.contains(localIndex - 2) &&\n !indices.contains(localIndex + 2) &&\n !indices.contains(localIndex + 1))\n return;\n\n // Calculate offset\n float interpolation = 0;\n float split = 0.5f;\n if(progress < split) {\n interpolation = Interpolation.pow2Out.apply(0, 1, progress / split);\n } else {\n interpolation = Interpolation.pow2In.apply(1, 0, (progress - split) / (1f - split));\n }\n float y = getLineHeight() * distance * interpolation * DEFAULT_DISTANCE;\n\n if(indices.contains(localIndex))\n y *= 2.15f;\n if(indices.contains(localIndex - 1) || indices.contains(localIndex + 1))\n y *= 1.35f;\n\n // Calculate fadeout\n float fadeout = calculateFadeout();\n y *= fadeout;\n\n // Apply changes\n glyph.yoffset -= y;\n }\n\n}\n"
},
{
"path": "src/main/java/com/rafaskoberg/gdx/typinglabel/effects/SlideEffect.java",
"content": "\npackage com.rafaskoberg.gdx.typinglabel.effects;\n\nimport com.badlogic.gdx.math.Interpolation;\nimport com.badlogic.gdx.math.MathUtils;\nimport com.badlogic.gdx.utils.IntFloatMap;\nimport com.rafaskoberg.gdx.typinglabel.Effect;\nimport com.rafaskoberg.gdx.typinglabel.TypingGlyph;\nimport com.rafaskoberg.gdx.typinglabel.TypingLabel;\n\n/** Moves the text horizontally easing it into the final position. Doesn't repeat itself. */\npublic class SlideEffect extends Effect {\n private static final float DEFAULT_DISTANCE = 2f;\n private static final float DEFAULT_INTENSITY = 0.375f;\n\n private float distance = 1; // How much of their height they should move\n private float intensity = 1; // How fast the glyphs should move\n private boolean elastic = false; // Whether or not the glyphs have an elastic movement\n\n private IntFloatMap timePassedByGlyphIndex = new IntFloatMap();\n\n public SlideEffect(TypingLabel label, String[] params) {\n super(label);\n\n // Distance\n if(params.length > 0) {\n this.distance = paramAsFloat(params[0], 1);\n }\n\n // Intensity\n if(params.length > 1) {\n this.intensity = paramAsFloat(params[1], 1);\n }\n\n // Elastic\n if(params.length > 2) {\n this.elastic = paramAsBoolean(params[2]);\n }\n }\n\n @Override\n protected void onApply(TypingGlyph glyph, int localIndex, float delta) {\n // Calculate real intensity\n float realIntensity = intensity * (elastic ? 3f : 1f) * DEFAULT_INTENSITY;\n\n // Calculate progress\n float timePassed = timePassedByGlyphIndex.getAndIncrement(localIndex, 0, delta);\n float progress = MathUtils.clamp(timePassed / realIntensity, 0, 1);\n\n // Calculate offset\n Interpolation interpolation = elastic ? Interpolation.swingOut : Interpolation.sine;\n float interpolatedValue = interpolation.apply(1, 0, progress);\n float x = getLineHeight() * distance * interpolatedValue * DEFAULT_DISTANCE;\n\n // Apply changes\n glyph.xoffset += x;\n }\n\n}\n"
},
{
"path": "src/main/java/com/rafaskoberg/gdx/typinglabel/effects/WaveEffect.java",
"content": "\npackage com.rafaskoberg.gdx.typinglabel.effects;\n\nimport com.badlogic.gdx.graphics.g2d.BitmapFont.Glyph;\nimport com.badlogic.gdx.math.Interpolation;\nimport com.rafaskoberg.gdx.typinglabel.Effect;\nimport com.rafaskoberg.gdx.typinglabel.TypingGlyph;\nimport com.rafaskoberg.gdx.typinglabel.TypingLabel;\n\n/** Moves the text vertically in a sine wave pattern. */\npublic class WaveEffect extends Effect {\n private static final float DEFAULT_FREQUENCY = 15f;\n private static final float DEFAULT_DISTANCE = 0.33f;\n private static final float DEFAULT_INTENSITY = 0.5f;\n\n private float distance = 1; // How much of their height they should move\n private float frequency = 1; // How frequently the wave pattern repeats\n private float intensity = 1; // How fast the glyphs should move\n\n public WaveEffect(TypingLabel label, String[] params) {\n super(label);\n\n // Distance\n if(params.length > 0) {\n this.distance = paramAsFloat(params[0], 1);\n }\n\n // Frequency\n if(params.length > 1) {\n this.frequency = paramAsFloat(params[1], 1);\n }\n\n // Intensity\n if(params.length > 2) {\n this.intensity = paramAsFloat(params[2], 1);\n }\n\n // Duration\n if(params.length > 3) {\n this.duration = paramAsFloat(params[3], -1);\n }\n }\n\n @Override\n protected void onApply(TypingGlyph glyph, int localIndex, float delta) {\n // Calculate progress\n float progressModifier = (1f / intensity) * DEFAULT_INTENSITY;\n float normalFrequency = (1f / frequency) * DEFAULT_FREQUENCY;\n float progressOffset = localIndex / normalFrequency;\n float progress = calculateProgress(progressModifier, progressOffset);\n\n // Calculate offset\n float y = getLineHeight() * distance * Interpolation.sine.apply(-1, 1, progress) * DEFAULT_DISTANCE;\n\n // Calculate fadeout\n float fadeout = calculateFadeout();\n y *= fadeout;\n\n // Apply changes\n glyph.yoffset += y;\n }\n\n}\n"
},
{
"path": "src/main/java/com/rafaskoberg/gdx/typinglabel/effects/WindEffect.java",
"content": "\npackage com.rafaskoberg.gdx.typinglabel.effects;\n\nimport com.rafaskoberg.gdx.typinglabel.Effect;\nimport com.rafaskoberg.gdx.typinglabel.TypingGlyph;\nimport com.rafaskoberg.gdx.typinglabel.TypingLabel;\nimport com.rafaskoberg.gdx.typinglabel.utils.SimplexNoise;\n\n/** Moves the text in a wind pattern. */\npublic class WindEffect extends Effect {\n private static final float DEFAULT_SPACING = 10f;\n private static final float DEFAULT_DISTANCE = 0.33f;\n private static final float DEFAULT_INTENSITY = 0.375f;\n private static final float DISTANCE_X_RATIO = 1.5f;\n private static final float DISTANCE_Y_RATIO = 1.0f;\n private static final float IDEAL_DELTA = 60f;\n\n private SimplexNoise noise = new SimplexNoise(1, 0.5f, 1f);\n private float noiseCursorX = 0;\n private float noiseCursorY = 0;\n\n private float distanceX = 1; // How much of their line height glyphs should move in the X axis\n private float distanceY = 1; // How much of their line height glyphs should move in the Y axis\n private float spacing = 1; // How much space there should be between waves\n private float intensity = 1; // How strong the wind should be\n\n public WindEffect(TypingLabel label, String[] params) {\n super(label);\n\n // Distance X\n if(params.length > 0) {\n this.distanceX = paramAsFloat(params[0], 1);\n }\n\n // Distance Y\n if(params.length > 1) {\n this.distanceY = paramAsFloat(params[1], 1);\n }\n\n // Spacing\n if(params.length > 2) {\n this.spacing = paramAsFloat(params[2], 1);\n }\n\n // Intensity\n if(params.length > 3) {\n this.intensity = paramAsFloat(params[3], 1);\n }\n\n // Duration\n if(params.length > 4) {\n this.duration = paramAsFloat(params[4], -1);\n }\n }\n\n @Override\n public void update(float delta) {\n super.update(delta);\n\n // Update noise cursor\n float changeAmount = 0.1f * intensity * DEFAULT_INTENSITY * delta * IDEAL_DELTA;\n noiseCursorX += changeAmount;\n noiseCursorY += changeAmount;\n }\n\n @Override\n protected void onApply(TypingGlyph glyph, int localIndex, float delta) {\n // Calculate progress\n float progressModifier = DEFAULT_INTENSITY / intensity;\n float normalSpacing = DEFAULT_SPACING / spacing;\n float progressOffset = localIndex / normalSpacing;\n float progress = calculateProgress(progressModifier, progressOffset);\n\n // Calculate noise\n float indexOffset = localIndex * 0.05f * spacing;\n float noiseX = noise.getNoise(noiseCursorX + indexOffset, 0);\n float noiseY = noise.getNoise(0, noiseCursorY + indexOffset);\n\n // Calculate offset\n float lineHeight = getLineHeight();\n float x = lineHeight * noiseX * progress * distanceX * DISTANCE_X_RATIO * DEFAULT_DISTANCE;\n float y = lineHeight * noiseY * progress * distanceY * DISTANCE_Y_RATIO * DEFAULT_DISTANCE;\n\n // Calculate fadeout\n float fadeout = calculateFadeout();\n x *= fadeout;\n y *= fadeout;\n\n // Add flag effect to X offset\n x = Math.abs(x) * -Math.signum(distanceX);\n\n // Apply changes\n glyph.xoffset += x;\n glyph.yoffset += y;\n }\n\n}\n"
},
{
"path": "src/main/java/com/rafaskoberg/gdx/typinglabel/utils/ColorUtils.java",
"content": "/*\n * Copyright 2014-2017 See AUTHORS file.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/*\n * Utility class borrowed from Vis-UI.\n */\n\npackage com.rafaskoberg.gdx.typinglabel.utils;\n\nimport com.badlogic.gdx.graphics.Color;\nimport com.badlogic.gdx.math.MathUtils;\n\n/**\n * Utilities for converting between RGB and HSV color systems.\n *\n * @author Kotcrab\n * @since 0.6.0\n */\npublic class ColorUtils {\n /**\n * Converts HSV to RGB\n *\n * @param h hue 0-360\n * @param s saturation 0-100\n * @param v value 0-100\n * @param alpha 0-1\n * @return RGB values in LibGDX {@link Color} class\n */\n public static Color HSVtoRGB(float h, float s, float v, float alpha) {\n Color c = HSVtoRGB(h, s, v);\n c.a = alpha;\n return c;\n }\n\n /**\n * Converts HSV color system to RGB\n *\n * @param h hue 0-360\n * @param s saturation 0-100\n * @param v value 0-100\n * @return RGB values in LibGDX {@link Color} class\n */\n public static Color HSVtoRGB(float h, float s, float v) {\n Color c = new Color(1, 1, 1, 1);\n HSVtoRGB(h, s, v, c);\n return c;\n }\n\n /**\n * Converts HSV color system to RGB\n *\n * @param h hue 0-360\n * @param s saturation 0-100\n * @param v value 0-100\n * @param targetColor color that result will be stored in\n * @return targetColor\n */\n public static Color HSVtoRGB(float h, float s, float v, Color targetColor) {\n if(h >= 360) h = 359.999f;\n float r, g, b;\n int i;\n float f, p, q, t;\n h = (float) Math.max(0.0, Math.min(360.0, h));\n s = (float) Math.max(0.0, Math.min(100.0, s));\n v = (float) Math.max(0.0, Math.min(100.0, v));\n s /= 100;\n v /= 100;\n h /= 60;\n i = MathUtils.floor(h);\n f = h - i;\n p = v * (1 - s);\n q = v * (1 - s * f);\n t = v * (1 - s * (1 - f));\n switch(i) {\n case 0:\n r = v;\n g = t;\n b = p;\n break;\n case 1:\n r = q;\n g = v;\n b = p;\n break;\n case 2:\n r = p;\n g = v;\n b = t;\n break;\n case 3:\n r = p;\n g = q;\n b = v;\n break;\n case 4:\n r = t;\n g = p;\n b = v;\n break;\n default:\n r = v;\n g = p;\n b = q;\n }\n\n targetColor.set(r, g, b, targetColor.a);\n return targetColor;\n }\n\n /**\n * Converts {@link Color} to HSV color system\n *\n * @return 3 element int array with hue (0-360), saturation (0-100) and value (0-100)\n */\n public static int[] RGBtoHSV(Color c) {\n return RGBtoHSV(c.r, c.g, c.b);\n }\n\n /**\n * Converts RGB to HSV color system\n *\n * @param r red 0-1\n * @param g green 0-1\n * @param b blue 0-1\n * @return 3 element int array with hue (0-360), saturation (0-100) and value (0-100)\n */\n public static int[] RGBtoHSV(float r, float g, float b) {\n float h, s, v;\n float min, max, delta;\n\n min = Math.min(Math.min(r, g), b);\n max = Math.max(Math.max(r, g), b);\n v = max;\n\n delta = max - min;\n\n if(max != 0)\n s = delta / max;\n else {\n s = 0;\n h = 0;\n return new int[]{MathUtils.round(h), MathUtils.round(s), MathUtils.round(v)};\n }\n\n if(delta == 0)\n h = 0;\n else {\n\n if(r == max)\n h = (g - b) / delta;\n else if(g == max)\n h = 2 + (b - r) / delta;\n else\n h = 4 + (r - g) / delta;\n }\n\n h *= 60;\n if(h < 0)\n h += 360;\n\n s *= 100;\n v *= 100;\n\n return new int[]{MathUtils.round(h), MathUtils.round(s), MathUtils.round(v)};\n }\n}"
},
{
"path": "src/main/java/com/rafaskoberg/gdx/typinglabel/utils/SimplexNoise.java",
"content": "package com.rafaskoberg.gdx.typinglabel.utils;\n\nimport com.badlogic.gdx.math.MathUtils;\n\n/**\n * A speed-improved simplex noise algorithm for 2D, 3D and 4D in Java.\n *
\n * Based on example code by Stefan Gustavson (stegu@itn.liu.se). Optimisations by Peter Eastman\n * (peastman@drizzle.stanford.edu). Better rank ordering method by Stefan Gustavson in 2012.\n *
\n * This could be speeded up even further, but it's useful as it is.\n *