public String getBaseUrl () {\r
return preloader.baseUrl;\r
}\r
+\r
+ public Preloader getPreloader () {\r
+ return preloader;\r
+ }\r
}\r
import java.io.Writer;\r
\r
import com.badlogic.gdx.Files.FileType;\r
+import com.badlogic.gdx.Gdx;\r
import com.badlogic.gdx.backends.gwt.preloader.Preloader;\r
import com.badlogic.gdx.files.FileHandle;\r
import com.badlogic.gdx.utils.GdxRuntimeException;\r
this.file = fileName;\r
this.type = type;\r
}\r
+ \r
+ public GwtFileHandle(String path) {\r
+ this.type = FileType.Internal;\r
+ this.preloader = ((GwtApplication)Gdx.app).getPreloader();\r
+ this.file = path;\r
+ }\r
\r
public String path () {\r
return file;\r
for(int i = 0; i < n; i++) {\r
int id = textures.get();\r
WebGLTexture texture = this.textures.get(id);\r
+ deallocateTextureId(id);\r
gl.deleteTexture(texture);\r
}\r
}\r
\r
@Override\r
public void glDrawElements (int mode, int count, int type, Buffer indices) {\r
- // FIXME this assumes that we actually use index buffers, not index arrays...\r
- gl.drawElements(mode, count, type, indices.position());\r
+ gl.drawElements(mode, count, type, indices.position()); // FIXME this is assuming WebGL supports client side buffers...\r
}\r
\r
@Override\r
\r
@Override\r
public void glReadPixels (int x, int y, int width, int height, int format, int type, Buffer pixels) {\r
- // FIXME\r
- throw new GdxRuntimeException("not implemented");\r
+ throw new GdxRuntimeException("Not supported by GWT backend");\r
}\r
\r
@Override\r
\r
@Override\r
public float getPpiX () {\r
- return 0;\r
+ return 96;\r
}\r
\r
@Override\r
public float getPpiY () {\r
- return 0;\r
+ return 96;\r
}\r
\r
@Override\r
public float getPpcX () {\r
- return 0;\r
+ return 96 / 2.54f;\r
}\r
\r
@Override\r
public float getPpcY () {\r
- return 0;\r
+ return 96 / 2.54f;\r
}\r
\r
@Override\r
\r
@Override\r
public float getDensity () {\r
- throw new GdxRuntimeException("No supported");\r
+ return 96 / 160;\r
}\r
\r
@Override\r
import com.badlogic.gdx.Gdx;\r
import com.badlogic.gdx.Input;\r
import com.badlogic.gdx.InputProcessor;\r
+import com.badlogic.gdx.utils.TimeUtils;\r
import com.google.gwt.core.client.JavaScriptObject;\r
import com.google.gwt.dom.client.Document;\r
import com.google.gwt.dom.client.Element;\r
this.deltaY = 0;\r
this.mouseX = (int)getRelativeX(e, canvas);\r
this.mouseY = (int)getRelativeY(e, canvas);\r
- this.currentEventTimeStamp = System.currentTimeMillis() * 1000;\r
+ this.currentEventTimeStamp = TimeUtils.nanoTime();\r
if(processor != null) processor.touchDown(mouseX, mouseY, 0, getButton(e.getButton()));\r
}\r
\r
this.deltaY = (int)getRelativeY(e, canvas) - mouseY;\r
this.mouseX = (int)getRelativeX(e, canvas);\r
this.mouseY = (int)getRelativeY(e, canvas);\r
- this.currentEventTimeStamp = System.currentTimeMillis() * 1000;\r
+ this.currentEventTimeStamp = TimeUtils.nanoTime();\r
if(processor != null) {\r
if(touched) processor.touchDragged(mouseX, mouseY, 0);\r
else processor.touchMoved(mouseX, mouseY);\r
this.deltaY = (int)getRelativeY(e, canvas) - mouseY;\r
this.mouseX = (int)getRelativeX(e, canvas);\r
this.mouseY = (int)getRelativeY(e, canvas);\r
- this.currentEventTimeStamp = System.currentTimeMillis() * 1000;\r
+ this.currentEventTimeStamp = TimeUtils.nanoTime();\r
this.touched = false;\r
if(processor != null) processor.touchUp(mouseX, mouseY, 0, getButton(e.getButton()));\r
}\r
package com.badlogic.gdx.assets;\r
\r
-import java.util.ArrayList;\r
-\r
import com.badlogic.gdx.assets.loaders.AssetLoader;\r
+import com.badlogic.gdx.assets.loaders.AsynchronousAssetLoader;\r
+import com.badlogic.gdx.assets.loaders.SynchronousAssetLoader;\r
+import com.badlogic.gdx.utils.Array;\r
\r
public class AssetLoadingTask {\r
AssetManager manager;\r
public AssetDescriptor assetDesc;\r
AssetLoader loader;\r
- public boolean cancel;\r
- public long startTime;\r
- public boolean dependenciesLoaded;\r
- public ArrayList<AssetDescriptor> dependencies;\r
+ boolean cancel;\r
+ long startTime;\r
+ boolean dependenciesLoaded;\r
+ Array<AssetDescriptor> dependencies;\r
+ Object asset;\r
\r
public AssetLoadingTask(AssetManager manager, AssetDescriptor desc, AssetLoader loader) {\r
this.manager = manager;\r
}\r
\r
public boolean update () {\r
- return false;\r
+ if(loader instanceof AsynchronousAssetLoader) {\r
+ handleAsynchLoader((AsynchronousAssetLoader)loader);\r
+ } else {\r
+ handleSynchLoader((SynchronousAssetLoader)loader);\r
+ }\r
+ return asset != null;\r
+ }\r
+ \r
+ private void handleSynchLoader (SynchronousAssetLoader loader) {\r
+ if(!dependenciesLoaded) {\r
+ Array<AssetDescriptor> dependencies = loader.getDependencies(assetDesc.fileName, assetDesc.params);\r
+ if (dependencies != null) {\r
+ for (AssetDescriptor desc : dependencies) {\r
+ manager.injectDependency(assetDesc.fileName, desc);\r
+ }\r
+ dependenciesLoaded = true;\r
+ } else {\r
+ // if we have no dependencies, we load the async part of the task immediately.\r
+ asset = loader.load(manager, assetDesc.fileName, assetDesc.params);\r
+ }\r
+ } else {\r
+ asset = loader.load(manager, assetDesc.fileName, assetDesc.params);\r
+ }\r
}\r
+\r
+ private void handleAsynchLoader(AsynchronousAssetLoader loader) {\r
+ if(!dependenciesLoaded) {\r
+ Array<AssetDescriptor> dependencies = loader.getDependencies(assetDesc.fileName, assetDesc.params);\r
+ if (dependencies != null) {\r
+ for (AssetDescriptor desc : dependencies) {\r
+ manager.injectDependency(assetDesc.fileName, desc);\r
+ }\r
+ dependenciesLoaded = true;\r
+ } else {\r
+ // we can load everything we are always on the rendering thread.\r
+ loader.loadAsync(manager, assetDesc.fileName, assetDesc.params);\r
+ asset = loader.loadSync(manager, assetDesc.fileName, assetDesc.params);\r
+ }\r
+ } else {\r
+ loader.loadAsync(manager, assetDesc.fileName, assetDesc.params);\r
+ asset = loader.loadSync(manager, assetDesc.fileName, assetDesc.params);\r
+ }\r
+ }\r
+ \r
public Object getAsset () {\r
- return null;\r
+ return asset;\r
}\r
}\r
import java.util.Stack;\r
\r
import com.badlogic.gdx.assets.loaders.AssetLoader;\r
+import com.badlogic.gdx.assets.loaders.BitmapFontLoader;\r
import com.badlogic.gdx.assets.loaders.FileHandleResolver;\r
+import com.badlogic.gdx.assets.loaders.MusicLoader;\r
+import com.badlogic.gdx.assets.loaders.PixmapLoader;\r
+import com.badlogic.gdx.assets.loaders.SoundLoader;\r
+import com.badlogic.gdx.assets.loaders.TextureAtlasLoader;\r
+import com.badlogic.gdx.assets.loaders.TextureLoader;\r
import com.badlogic.gdx.assets.loaders.resolvers.InternalFileHandleResolver;\r
+import com.badlogic.gdx.audio.Music;\r
+import com.badlogic.gdx.audio.Sound;\r
+import com.badlogic.gdx.graphics.Pixmap;\r
+import com.badlogic.gdx.graphics.Texture;\r
+import com.badlogic.gdx.graphics.g2d.BitmapFont;\r
+import com.badlogic.gdx.graphics.g2d.TextureAtlas;\r
import com.badlogic.gdx.utils.Array;\r
import com.badlogic.gdx.utils.Disposable;\r
import com.badlogic.gdx.utils.GdxRuntimeException;\r
\r
/** Creates a new AssetManager with all default loaders. */\r
public AssetManager (FileHandleResolver resolver) {\r
-// setLoader(BitmapFont.class, new BitmapFontLoader(resolver));\r
-// setLoader(Music.class, new MusicLoader(resolver));\r
-// setLoader(Pixmap.class, new PixmapLoader(resolver));\r
-// setLoader(Sound.class, new SoundLoader(resolver));\r
-// setLoader(TextureAtlas.class, new TextureAtlasLoader(resolver));\r
-// setLoader(Texture.class, new TextureLoader(resolver));\r
+ setLoader(BitmapFont.class, new BitmapFontLoader(resolver));\r
+ setLoader(Music.class, new MusicLoader(resolver));\r
+ setLoader(Pixmap.class, new PixmapLoader(resolver));\r
+ setLoader(Sound.class, new SoundLoader(resolver));\r
+ setLoader(TextureAtlas.class, new TextureAtlasLoader(resolver));\r
+ setLoader(Texture.class, new TextureLoader(resolver));\r
// setLoader(Skin.class, new SkinLoader(resolver));\r
// setLoader(TileMapRenderer.class, new TileMapRendererLoader(resolver));\r
}\r
private void addTask (AssetDescriptor assetDesc) {\r
AssetLoader loader = loaders.get(assetDesc.type);\r
if (loader == null) throw new GdxRuntimeException("No loader for type: " + assetDesc.type.getName());\r
- // FIXME\r
-// tasks.push(new AssetLoadingTask(this, assetDesc, loader, threadPool));\r
+ tasks.push(new AssetLoadingTask(this, assetDesc, loader));\r
}\r
\r
/** Updates the current task on the top of the task stack.\r
public synchronized void dispose () {\r
// log.debug("Disposing.");\r
clear();\r
- // FIXME\r
-// threadPool.shutdown();\r
-// try {\r
-// threadPool.awaitTermination(Long.MAX_VALUE, TimeUnit.SECONDS);\r
-// } catch (InterruptedException e) {\r
-// new GdxRuntimeException("Couldn't shutdown loading thread");\r
-// }\r
}\r
\r
/** Clears and disposes all assets and the preloading queue. */\r
--- /dev/null
+/*******************************************************************************\r
+ * Copyright 2011 See AUTHORS file.\r
+ * \r
+ * Licensed under the Apache License, Version 2.0 (the "License");\r
+ * you may not use this file except in compliance with the License.\r
+ * You may obtain a copy of the License at\r
+ * \r
+ * http://www.apache.org/licenses/LICENSE-2.0\r
+ * \r
+ * Unless required by applicable law or agreed to in writing, software\r
+ * distributed under the License is distributed on an "AS IS" BASIS,\r
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ * See the License for the specific language governing permissions and\r
+ * limitations under the License.\r
+ ******************************************************************************/\r
+\r
+package com.badlogic.gdx.assets.loaders;\r
+\r
+import com.badlogic.gdx.assets.AssetDescriptor;\r
+import com.badlogic.gdx.assets.AssetLoaderParameters;\r
+import com.badlogic.gdx.assets.AssetManager;\r
+import com.badlogic.gdx.files.FileHandle;\r
+import com.badlogic.gdx.graphics.Pixmap;\r
+import com.badlogic.gdx.graphics.Pixmap.Format;\r
+import com.badlogic.gdx.graphics.Texture;\r
+import com.badlogic.gdx.graphics.Texture.TextureFilter;\r
+import com.badlogic.gdx.graphics.Texture.TextureWrap;\r
+import com.badlogic.gdx.graphics.TextureData;\r
+import com.badlogic.gdx.graphics.glutils.FileTextureData;\r
+import com.badlogic.gdx.utils.Array;\r
+\r
+public class TextureLoader extends AsynchronousAssetLoader<Texture, TextureLoader.TextureParameter> {\r
+ TextureData data;\r
+ Texture texture;\r
+\r
+ public TextureLoader (FileHandleResolver resolver) {\r
+ super(resolver);\r
+ }\r
+\r
+ @Override\r
+ public void loadAsync (AssetManager manager, String fileName, TextureParameter parameter) {\r
+ if (parameter == null || (parameter != null && parameter.textureData == null)) {\r
+ Pixmap pixmap = null;\r
+ Format format = null;\r
+ boolean genMipMaps = false;\r
+ texture = null;\r
+\r
+ if (parameter != null) {\r
+ format = parameter.format;\r
+ genMipMaps = parameter.genMipMaps;\r
+ texture = parameter.texture;\r
+ }\r
+\r
+ FileHandle handle = resolve(fileName);\r
+ pixmap = new Pixmap(handle);\r
+ data = new FileTextureData(handle, pixmap, format, genMipMaps);\r
+ } else {\r
+ data = parameter.textureData;\r
+ if(!data.isPrepared()) data.prepare();\r
+ texture = parameter.texture;\r
+ }\r
+ }\r
+\r
+ @Override\r
+ public Texture loadSync (AssetManager manager, String fileName, TextureParameter parameter) {\r
+ Texture texture = this.texture;\r
+ if (texture != null) {\r
+ texture.load(data);\r
+ } else {\r
+ texture = new Texture(data);\r
+ }\r
+ if (parameter != null) {\r
+ texture.setFilter(parameter.minFilter, parameter.magFilter);\r
+ texture.setWrap(parameter.wrapU, parameter.wrapV);\r
+ }\r
+ return texture;\r
+ }\r
+\r
+ @Override\r
+ public Array<AssetDescriptor> getDependencies (String fileName, TextureParameter parameter) {\r
+ return null;\r
+ }\r
+\r
+ static public class TextureParameter extends AssetLoaderParameters<Texture> {\r
+ /** the format of the final Texture. Uses the source images format if null **/\r
+ public Format format = null;\r
+ /** whether to generate mipmaps **/\r
+ public boolean genMipMaps = false;\r
+ /** The texture to put the {@link TextureData} in, optional. **/\r
+ public Texture texture = null;\r
+ /** TextureData for textures created on the fly, optional. When set, all format and genMipMaps are ignored */\r
+ public TextureData textureData = null;\r
+ public TextureFilter minFilter = TextureFilter.Nearest;\r
+ public TextureFilter magFilter = TextureFilter.Nearest;\r
+ public TextureWrap wrapU = TextureWrap.ClampToEdge;\r
+ public TextureWrap wrapV = TextureWrap.ClampToEdge;\r
+ }\r
+}\r
--- /dev/null
+/*******************************************************************************\r
+ * Copyright 2011 See AUTHORS file.\r
+ * \r
+ * Licensed under the Apache License, Version 2.0 (the "License");\r
+ * you may not use this file except in compliance with the License.\r
+ * You may obtain a copy of the License at\r
+ * \r
+ * http://www.apache.org/licenses/LICENSE-2.0\r
+ * \r
+ * Unless required by applicable law or agreed to in writing, software\r
+ * distributed under the License is distributed on an "AS IS" BASIS,\r
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ * See the License for the specific language governing permissions and\r
+ * limitations under the License.\r
+ ******************************************************************************/\r
+\r
+package com.badlogic.gdx.assets.loaders.resolvers;\r
+\r
+import com.badlogic.gdx.Gdx;\r
+import com.badlogic.gdx.assets.loaders.FileHandleResolver;\r
+import com.badlogic.gdx.assets.loaders.resolvers.ResolutionFileResolver.Resolution;\r
+import com.badlogic.gdx.backends.gwt.GwtFileHandle;\r
+import com.badlogic.gdx.files.FileHandle;\r
+\r
+public class ResolutionFileResolver implements FileHandleResolver {\r
+ public static class Resolution {\r
+ int portraitWidth;\r
+ int portraitHeight;\r
+ String suffix;\r
+\r
+ public Resolution (int portraitWidth, int portraitHeight, String suffix) {\r
+ this.portraitWidth = portraitWidth;\r
+ this.portraitHeight = portraitHeight;\r
+ this.suffix = suffix;\r
+ }\r
+ }\r
+\r
+ final FileHandleResolver baseResolver;\r
+ final Resolution[] descriptors;\r
+\r
+ public ResolutionFileResolver (FileHandleResolver baseResolver, Resolution... descriptors) {\r
+ this.baseResolver = baseResolver;\r
+ this.descriptors = descriptors;\r
+ }\r
+\r
+ @Override\r
+ public FileHandle resolve (String fileName) {\r
+ Resolution bestDesc = choose(descriptors);\r
+ FileHandle originalHandle = new GwtFileHandle(fileName);\r
+ FileHandle handle = baseResolver.resolve(resolve(originalHandle, bestDesc.suffix));\r
+ if (!handle.exists()) handle = baseResolver.resolve(fileName);\r
+ return handle;\r
+ }\r
+\r
+ protected String resolve (FileHandle originalHandle, String suffix) {\r
+ return originalHandle.parent() + "/" + suffix + "/" + originalHandle.name();\r
+ }\r
+\r
+ static public Resolution choose (Resolution... descriptors) {\r
+ int width = 0;\r
+ if (Gdx.graphics.getWidth() > Gdx.graphics.getHeight()) {\r
+ width = Gdx.graphics.getHeight();\r
+ } else {\r
+ width = Gdx.graphics.getWidth();\r
+ }\r
+\r
+ Resolution bestDesc = null;\r
+ // Find lowest.\r
+ int best = Integer.MAX_VALUE;\r
+ for (int i = 0, n = descriptors.length; i < n; i++) {\r
+ if (descriptors[i].portraitWidth < best) {\r
+ best = descriptors[i].portraitWidth;\r
+ bestDesc = descriptors[i];\r
+ }\r
+ }\r
+ // Find higher, but not over the screen res.\r
+ best = Integer.MAX_VALUE;\r
+ for (int i = 0, n = descriptors.length; i < n; i++) {\r
+ if (descriptors[i].portraitWidth <= width) {\r
+ best = descriptors[i].portraitWidth;\r
+ bestDesc = descriptors[i];\r
+ }\r
+ }\r
+ return bestDesc;\r
+ }\r
+}\r
--- /dev/null
+/*******************************************************************************\r
+ * Copyright 2011 See AUTHORS file.\r
+ * \r
+ * Licensed under the Apache License, Version 2.0 (the "License");\r
+ * you may not use this file except in compliance with the License.\r
+ * You may obtain a copy of the License at\r
+ * \r
+ * http://www.apache.org/licenses/LICENSE-2.0\r
+ * \r
+ * Unless required by applicable law or agreed to in writing, software\r
+ * distributed under the License is distributed on an "AS IS" BASIS,\r
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ * See the License for the specific language governing permissions and\r
+ * limitations under the License.\r
+ ******************************************************************************/\r
+\r
+package com.badlogic.gdx.files;\r
+\r
+import java.io.InputStream;\r
+import java.io.OutputStream;\r
+\r
+import com.badlogic.gdx.Files.FileType;\r
+import com.badlogic.gdx.Gdx;\r
+import com.badlogic.gdx.backends.gwt.GwtApplication;\r
+import com.badlogic.gdx.backends.gwt.GwtFileHandle;\r
+\r
+/** A FileHandle intended to be subclassed for the purpose of implementing {@link #read()} and/or {@link #write(boolean)}. Methods\r
+ * that would manipulate the file instead throw UnsupportedOperationException.\r
+ * @author Nathan Sweet */\r
+public abstract class FileHandleStream extends GwtFileHandle {\r
+ public FileHandleStream (String path) {\r
+ super(((GwtApplication)Gdx.app).getPreloader(), path, FileType.Internal);\r
+ }\r
+\r
+ public boolean isDirectory () {\r
+ return false;\r
+ }\r
+\r
+ public long length () {\r
+ return 0;\r
+ }\r
+\r
+ public boolean exists () {\r
+ return true;\r
+ }\r
+\r
+ public FileHandle child (String name) {\r
+ throw new UnsupportedOperationException();\r
+ }\r
+\r
+ public FileHandle parent () {\r
+ throw new UnsupportedOperationException();\r
+ }\r
+\r
+ public InputStream read () {\r
+ throw new UnsupportedOperationException();\r
+ }\r
+\r
+ public OutputStream write (boolean overwrite) {\r
+ throw new UnsupportedOperationException();\r
+ }\r
+\r
+ public FileHandle[] list () {\r
+ throw new UnsupportedOperationException();\r
+ }\r
+\r
+ public void mkdirs () {\r
+ throw new UnsupportedOperationException();\r
+ }\r
+\r
+ public boolean delete () {\r
+ throw new UnsupportedOperationException();\r
+ }\r
+\r
+ public boolean deleteDirectory () {\r
+ throw new UnsupportedOperationException();\r
+ }\r
+\r
+ public void copyTo (FileHandle dest) {\r
+ throw new UnsupportedOperationException();\r
+ }\r
+\r
+ public void moveTo (FileHandle dest) {\r
+ throw new UnsupportedOperationException();\r
+ }\r
+}\r
public Format getFormat () {\r
return format;\r
}\r
+ \r
+ public int getGLInternalFormat() {\r
+ return GL20.GL_RGBA;\r
+ }\r
+ \r
+ public int getGLFormat() {\r
+ return GL20.GL_RGBA;\r
+ }\r
+ \r
+ public int getGLType() {\r
+ return GL20.GL_UNSIGNED_BYTE;\r
+ }\r
\r
public int getWidth () {\r
return width;\r
import java.nio.IntBuffer;\r
\r
import com.badlogic.gdx.Gdx;\r
+import com.badlogic.gdx.assets.AssetManager;\r
import com.badlogic.gdx.files.FileHandle;\r
import com.badlogic.gdx.graphics.Pixmap.Format;\r
import com.badlogic.gdx.graphics.TextureData.TextureDataType;\r
* @param x The x coordinate in pixels\r
* @param y The y coordinate in pixels */\r
public void draw (Pixmap pixmap, int x, int y) {\r
- throw new GdxRuntimeException("can't draw to a managed texture");\r
+ if (data.isManaged()) throw new GdxRuntimeException("can't draw to a managed texture");\r
+\r
+ Gdx.gl.glBindTexture(GL10.GL_TEXTURE_2D, glHandle);\r
+ Gdx.gl.glTexSubImage2D(GL10.GL_TEXTURE_2D, 0, x, y, pixmap.getWidth(), pixmap.getHeight(), pixmap.getGLFormat(),\r
+ pixmap.getGLType(), pixmap.getPixels());\r
}\r
\r
/** @return the width of the texture in pixels */\r
Gdx.gl.glDeleteTextures(1, buffer);\r
glHandle = 0;\r
}\r
+ \r
+ public static void setAssetManager(AssetManager manager) {\r
+ // FIXME well not really, no pause/resume cycle\r
+ }\r
}\r
--- /dev/null
+/*******************************************************************************\r
+ * Copyright 2011 See AUTHORS file.\r
+ * \r
+ * Licensed under the Apache License, Version 2.0 (the "License");\r
+ * you may not use this file except in compliance with the License.\r
+ * You may obtain a copy of the License at\r
+ * \r
+ * http://www.apache.org/licenses/LICENSE-2.0\r
+ * \r
+ * Unless required by applicable law or agreed to in writing, software\r
+ * distributed under the License is distributed on an "AS IS" BASIS,\r
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ * See the License for the specific language governing permissions and\r
+ * limitations under the License.\r
+ ******************************************************************************/\r
+\r
+package com.badlogic.gdx.graphics.g2d;\r
+\r
+import java.io.BufferedReader;\r
+import java.io.File;\r
+import java.io.FileWriter;\r
+import java.io.IOException;\r
+import java.io.InputStream;\r
+import java.io.InputStreamReader;\r
+import java.io.Writer;\r
+\r
+import com.badlogic.gdx.files.FileHandle;\r
+import com.badlogic.gdx.graphics.Texture;\r
+import com.badlogic.gdx.utils.Array;\r
+import com.badlogic.gdx.utils.Disposable;\r
+import com.badlogic.gdx.utils.GdxRuntimeException;\r
+\r
+/**\r
+ * See <a href="http://www.badlogicgames.com/wordpress/?p=1255">http://www.badlogicgames.com/wordpress/?p=1255</a>\r
+ * @author mzechner\r
+ *\r
+ */\r
+public class ParticleEffect implements Disposable {\r
+ private final Array<ParticleEmitter> emitters;\r
+\r
+ public ParticleEffect () {\r
+ emitters = new Array(8);\r
+ }\r
+\r
+ public ParticleEffect (ParticleEffect effect) {\r
+ emitters = new Array(true, effect.emitters.size);\r
+ for (int i = 0, n = effect.emitters.size; i < n; i++)\r
+ emitters.add(new ParticleEmitter(effect.emitters.get(i)));\r
+ }\r
+\r
+ public void start () {\r
+ for (int i = 0, n = emitters.size; i < n; i++)\r
+ emitters.get(i).start();\r
+ }\r
+\r
+ public void update (float delta) {\r
+ for (int i = 0, n = emitters.size; i < n; i++)\r
+ emitters.get(i).update(delta);\r
+ }\r
+\r
+ public void draw (SpriteBatch spriteBatch) {\r
+ for (int i = 0, n = emitters.size; i < n; i++)\r
+ emitters.get(i).draw(spriteBatch);\r
+ }\r
+\r
+ public void draw (SpriteBatch spriteBatch, float delta) {\r
+ for (int i = 0, n = emitters.size; i < n; i++)\r
+ emitters.get(i).draw(spriteBatch, delta);\r
+ }\r
+\r
+ public void allowCompletion () {\r
+ for (int i = 0, n = emitters.size; i < n; i++)\r
+ emitters.get(i).allowCompletion();\r
+ }\r
+\r
+ public boolean isComplete () {\r
+ for (int i = 0, n = emitters.size; i < n; i++) {\r
+ ParticleEmitter emitter = emitters.get(i);\r
+ if (emitter.isContinuous()) return false;\r
+ if (!emitter.isComplete()) return false;\r
+ }\r
+ return true;\r
+ }\r
+\r
+ public void setDuration (int duration) {\r
+ for (int i = 0, n = emitters.size; i < n; i++) {\r
+ ParticleEmitter emitter = emitters.get(i);\r
+ emitter.setContinuous(false);\r
+ emitter.duration = duration;\r
+ emitter.durationTimer = 0;\r
+ }\r
+ }\r
+\r
+ public void setPosition (float x, float y) {\r
+ for (int i = 0, n = emitters.size; i < n; i++)\r
+ emitters.get(i).setPosition(x, y);\r
+ }\r
+\r
+ public void setFlip (boolean flipX, boolean flipY) {\r
+ for (int i = 0, n = emitters.size; i < n; i++)\r
+ emitters.get(i).setFlip(flipX, flipY);\r
+ }\r
+\r
+ public Array<ParticleEmitter> getEmitters () {\r
+ return emitters;\r
+ }\r
+\r
+ /** Returns the emitter with the specified name, or null. */\r
+ public ParticleEmitter findEmitter (String name) {\r
+ for (int i = 0, n = emitters.size; i < n; i++) {\r
+ ParticleEmitter emitter = emitters.get(i);\r
+ if (emitter.getName().equals(name)) return emitter;\r
+ }\r
+ return null;\r
+ }\r
+\r
+ public void save (File file) {\r
+ throw new GdxRuntimeException("Not supported in GWT backend");\r
+ }\r
+\r
+ public void load (FileHandle effectFile, FileHandle imagesDir) {\r
+ loadEmitters(effectFile);\r
+ loadEmitterImages(imagesDir);\r
+ }\r
+\r
+ public void load (FileHandle effectFile, TextureAtlas atlas) {\r
+ loadEmitters(effectFile);\r
+ loadEmitterImages(atlas);\r
+ }\r
+\r
+ public void loadEmitters (FileHandle effectFile) {\r
+ InputStream input = effectFile.read();\r
+ emitters.clear();\r
+ BufferedReader reader = null;\r
+ try {\r
+ reader = new BufferedReader(new InputStreamReader(input), 512);\r
+ while (true) {\r
+ ParticleEmitter emitter = new ParticleEmitter(reader);\r
+ reader.readLine();\r
+ emitter.setImagePath(reader.readLine());\r
+ emitters.add(emitter);\r
+ if (reader.readLine() == null) break;\r
+ if (reader.readLine() == null) break;\r
+ }\r
+ } catch (IOException ex) {\r
+ throw new GdxRuntimeException("Error loading effect: " + effectFile, ex);\r
+ } finally {\r
+ try {\r
+ if (reader != null) reader.close();\r
+ } catch (IOException ex) {\r
+ }\r
+ }\r
+ }\r
+\r
+ public void loadEmitterImages (TextureAtlas atlas) {\r
+ for (int i = 0, n = emitters.size; i < n; i++) {\r
+ ParticleEmitter emitter = emitters.get(i);\r
+ String imagePath = emitter.getImagePath();\r
+ if (imagePath == null) continue;\r
+ String imageName = new File(imagePath.replace('\\', '/')).getName();\r
+ int lastDotIndex = imageName.lastIndexOf('.');\r
+ if (lastDotIndex != -1) imageName = imageName.substring(0, lastDotIndex);\r
+ Sprite sprite = atlas.createSprite(imageName);\r
+ if (sprite == null) throw new IllegalArgumentException("SpriteSheet missing image: " + imageName);\r
+ emitter.setSprite(sprite);\r
+ }\r
+ }\r
+\r
+ public void loadEmitterImages (FileHandle imagesDir) {\r
+ for (int i = 0, n = emitters.size; i < n; i++) {\r
+ ParticleEmitter emitter = emitters.get(i);\r
+ String imagePath = emitter.getImagePath();\r
+ if (imagePath == null) continue;\r
+ String imageName = new File(imagePath.replace('\\', '/')).getName();\r
+ emitter.setSprite(new Sprite(loadTexture(imagesDir.child(imageName))));\r
+ }\r
+ }\r
+\r
+ protected Texture loadTexture (FileHandle file) {\r
+ return new Texture(file, false);\r
+ }\r
+\r
+ /** Disposes the texture for each sprite for each ParticleEmitter. */\r
+ public void dispose () {\r
+ for (int i = 0, n = emitters.size; i < n; i++) {\r
+ ParticleEmitter emitter = emitters.get(i);\r
+ emitter.getSprite().getTexture().dispose();\r
+ }\r
+ }\r
+}\r
private boolean invalidated;\r
\r
/** direct buffer for passing float and int uniform arrays **/\r
- private ByteBuffer buffer = null;\r
private FloatBuffer floatBuffer = null;\r
\r
public ShaderProgram (FileHandle vertexShader, FileHandle fragmentShader) {\r
}\r
\r
private void ensureBufferCapacity (int numBytes) {\r
- if (buffer == null || buffer.capacity() != numBytes) {\r
- buffer = BufferUtils.newByteBuffer(numBytes);\r
- floatBuffer = buffer.asFloatBuffer();\r
+ if (floatBuffer == null || floatBuffer.capacity() != numBytes / 4) {\r
+ floatBuffer = BufferUtils.newFloatBuffer(numBytes / 4);\r
}\r
}\r
\r
return true;\r
}\r
\r
- static void matrix4_mulVec(float[] mat, float[] vec) {\r
- float x = vec[0] * mat[M00] + vec[1] * mat[M01] + vec[2] * mat[M02] + mat[M03];\r
- float y = vec[0] * mat[M10] + vec[1] * mat[M11] + vec[2] * mat[M12] + mat[M13];\r
- float z = vec[0] * mat[M20] + vec[1] * mat[M21] + vec[2] * mat[M22] + mat[M23];\r
- vec[0] = x;\r
- vec[1] = y;\r
- vec[2] = z;\r
+ static void matrix4_mulVec(float[] mat, float[] vec, int offset) {\r
+ float x = vec[offset + 0] * mat[M00] + vec[offset + 1] * mat[M01] + vec[offset + 2] * mat[M02] + mat[M03];\r
+ float y = vec[offset + 0] * mat[M10] + vec[offset + 1] * mat[M11] + vec[offset + 2] * mat[M12] + mat[M13];\r
+ float z = vec[offset + 0] * mat[M20] + vec[offset + 1] * mat[M21] + vec[offset + 2] * mat[M22] + mat[M23];\r
+ vec[offset + 0] = x;\r
+ vec[offset + 1] = y;\r
+ vec[offset + 2] = z;\r
}\r
\r
- static void matrix4_proj(float[] mat, float[] vec) {\r
- float inv_w = 1.0f / (vec[0] * mat[M30] + vec[1] * mat[M31] + vec[2] * mat[M32] + mat[M33]);\r
- float x = (vec[0] * mat[M00] + vec[1] * mat[M01] + vec[2] * mat[M02] + mat[M03]) * inv_w;\r
- float y = (vec[0] * mat[M10] + vec[1] * mat[M11] + vec[2] * mat[M12] + mat[M13]) * inv_w; \r
- float z = (vec[0] * mat[M20] + vec[1] * mat[M21] + vec[2] * mat[M22] + mat[M23]) * inv_w;\r
- vec[0] = x;\r
- vec[1] = y;\r
- vec[2] = z;\r
+ static void matrix4_proj(float[] mat, float[] vec, int offset) {\r
+ float inv_w = 1.0f / (vec[offset + 0] * mat[M30] + vec[offset + 1] * mat[M31] + vec[offset + 2] * mat[M32] + mat[M33]);\r
+ float x = (vec[offset + 0] * mat[M00] + vec[offset + 1] * mat[M01] + vec[offset + 2] * mat[M02] + mat[M03]) * inv_w;\r
+ float y = (vec[offset + 0] * mat[M10] + vec[offset + 1] * mat[M11] + vec[offset + 2] * mat[M12] + mat[M13]) * inv_w; \r
+ float z = (vec[offset + 0] * mat[M20] + vec[offset + 1] * mat[M21] + vec[offset + 2] * mat[M22] + mat[M23]) * inv_w;\r
+ vec[offset + 0] = x;\r
+ vec[offset + 1] = y;\r
+ vec[offset + 2] = z;\r
}\r
\r
- static void matrix4_rot(float[] mat, float[] vec) {\r
- float x = vec[0] * mat[M00] + vec[1] * mat[M01] + vec[2] * mat[M02];\r
- float y = vec[0] * mat[M10] + vec[1] * mat[M11] + vec[2] * mat[M12];\r
- float z = vec[0] * mat[M20] + vec[1] * mat[M21] + vec[2] * mat[M22];\r
- vec[0] = x;\r
- vec[1] = y;\r
- vec[2] = z;\r
+ static void matrix4_rot(float[] mat, float[] vec, int offset) {\r
+ float x = vec[offset + 0] * mat[M00] + vec[offset + 1] * mat[M01] + vec[offset + 2] * mat[M02];\r
+ float y = vec[offset + 0] * mat[M10] + vec[offset + 1] * mat[M11] + vec[offset + 2] * mat[M12];\r
+ float z = vec[offset + 0] * mat[M20] + vec[offset + 1] * mat[M21] + vec[offset + 2] * mat[M22];\r
+ vec[offset + 0] = x;\r
+ vec[offset + 1] = y;\r
+ vec[offset + 2] = z;\r
}\r
\r
/** Multiplies the matrix mata with matrix matb, storing the result in mata. The arrays are assumed to hold 4x4 column major\r
* @param mat the matrix\r
* @param vec the vector. */\r
public static void mulVec (float[] mat, float[] vec) {\r
- matrix4_mulVec(mat, vec);\r
+ matrix4_mulVec(mat, vec, 0);\r
}\r
\r
/** Multiplies the vectors with the given matrix. The matrix array is assumed to hold a 4x4 column major matrix as you can get\r
* @param numVecs the number of vectors\r
* @param stride the stride between vectors in floats */\r
public static void mulVec (float[] mat, float[] vecs, int offset, int numVecs, int stride) {\r
- // FIXME\r
-// float* vecPtr = vecs + offset;\r
-// for(int i = 0; i < numVecs; i++) {\r
-// matrix4_mulVec(mat, vecPtr);\r
-// vecPtr += stride;\r
-// }\r
+ for(int i = 0; i < numVecs; i++) {\r
+ matrix4_mulVec(mat, vecs, offset);\r
+ offset += stride;\r
+ }\r
}\r
\r
/** Multiplies the vector with the given matrix, performing a division by w. The matrix array is assumed to hold a 4x4 column\r
* @param mat the matrix\r
* @param vec the vector. */\r
public static void prj (float[] mat, float[] vec) {\r
- matrix4_proj(mat, vec);\r
+ matrix4_proj(mat, vec, 0);\r
}\r
\r
/** Multiplies the vectors with the given matrix, , performing a division by w. The matrix array is assumed to hold a 4x4 column\r
* @param numVecs the number of vectors\r
* @param stride the stride between vectors in floats */\r
public static void prj (float[] mat, float[] vecs, int offset, int numVecs, int stride) {\r
- // FIXME\r
-// float* vecPtr = vecs + offset;\r
-// for(int i = 0; i < numVecs; i++) {\r
-// matrix4_proj(mat, vecPtr);\r
-// vecPtr += stride;\r
-// }\r
+ for(int i = 0; i < numVecs; i++) {\r
+ matrix4_proj(mat, vecs, offset);\r
+ offset += stride;\r
+ }\r
}\r
\r
/** Multiplies the vector with the top most 3x3 sub-matrix of the given matrix. The matrix array is assumed to hold a 4x4 column\r
* @param mat the matrix\r
* @param vec the vector. */\r
public static void rot (float[] mat, float[] vec) {\r
- matrix4_rot(mat, vec);\r
+ matrix4_rot(mat, vec, 0);\r
}\r
\r
/** Multiplies the vectors with the top most 3x3 sub-matrix of the given matrix. The matrix array is assumed to hold a 4x4\r
* @param numVecs the number of vectors\r
* @param stride the stride between vectors in floats */\r
public static void rot (float[] mat, float[] vecs, int offset, int numVecs, int stride) {\r
- // FIXME\r
-// float* vecPtr = vecs + offset;\r
-// for(int i = 0; i < numVecs; i++) {\r
-// matrix4_rot(mat, vecPtr);\r
-// vecPtr += stride;\r
-// }\r
+ for(int i = 0; i < numVecs; i++) {\r
+ matrix4_rot(mat, vecs, offset);\r
+ offset += stride;\r
+ }\r
}\r
\r
/** Computes the inverse of the given matrix. The matrix array is assumed to hold a 4x4 column major matrix as you can get from\r
--- /dev/null
+\r
+package com.badlogic.gdx.utils;\r
+\r
+import com.badlogic.gdx.math.MathUtils;\r
+\r
+// BOZO - Add iterator.\r
+\r
+/** An ordered or unordered map of objects. This implementation uses arrays to store the keys and values, which means\r
+ * {@link #getKey(Object, boolean)} does a comparison for each key in the map. This may be acceptable for small maps and has the\r
+ * benefits that {@link #put(Object, Object)} and the keys and values can be accessed by index, which makes iteration fast. Like\r
+ * {@link Array}, if ordered is false, this class avoids a memory copy when removing elements (the last element is moved to the\r
+ * removed element's position).\r
+ * @author Nathan Sweet */\r
+public class ArrayMap<K, V> {\r
+ public K[] keys;\r
+ public V[] values;\r
+ public int size;\r
+ public boolean ordered;\r
+\r
+ /** Creates an ordered map with a capacity of 16. */\r
+ public ArrayMap () {\r
+ this(true, 16);\r
+ }\r
+\r
+ /** Creates an ordered map with the specified capacity. */\r
+ public ArrayMap (int capacity) {\r
+ this(true, capacity);\r
+ }\r
+\r
+ /** @param ordered If false, methods that remove elements may change the order of other elements in the arrays, which avoids a\r
+ * memory copy.\r
+ * @param capacity Any elements added beyond this will cause the backing arrays to be grown. */\r
+ public ArrayMap (boolean ordered, int capacity) {\r
+ this.ordered = ordered;\r
+ keys = (K[])new Object[capacity];\r
+ values = (V[])new Object[capacity];\r
+ }\r
+\r
+ /** Creates a new map with {@link #keys} and {@link #values} of the specified type.\r
+ * @param ordered If false, methods that remove elements may change the order of other elements in the arrays, which avoids a\r
+ * memory copy.\r
+ * @param capacity Any elements added beyond this will cause the backing arrays to be grown. */\r
+ public ArrayMap (boolean ordered, int capacity, Class<K> keyArrayType, Class<V> valueArrayType) {\r
+ this.ordered = ordered;\r
+ keys = (K[])new Object[capacity];\r
+ values = (V[])new Object[capacity];\r
+ }\r
+\r
+ /** Creates an ordered map with {@link #keys} and {@link #values} of the specified type and a capacity of 16. */\r
+ public ArrayMap (Class<K> keyArrayType, Class<V> valueArrayType) {\r
+ this(false, 16, keyArrayType, valueArrayType);\r
+ }\r
+\r
+ /** Creates a new map containing the elements in the specified map. The new map will have the same type of backing arrays and\r
+ * will be ordered if the specified map is ordered. The capacity is set to the number of elements, so any subsequent elements\r
+ * added will cause the backing arrays to be grown. */\r
+ public ArrayMap (ArrayMap array) {\r
+ this(array.ordered, array.size, (Class<K>)array.keys.getClass().getComponentType(), (Class<V>)array.values.getClass()\r
+ .getComponentType());\r
+ size = array.size;\r
+ System.arraycopy(array.keys, 0, keys, 0, size);\r
+ System.arraycopy(array.values, 0, values, 0, size);\r
+ }\r
+\r
+ public void put (K key, V value) {\r
+ if (size == keys.length) resize(Math.max(8, (int)(size * 1.75f)));\r
+ keys[size] = key;\r
+ values[size++] = value;\r
+ }\r
+\r
+ public void addAll (ArrayMap map) {\r
+ addAll(map, 0, map.size);\r
+ }\r
+\r
+ public void addAll (ArrayMap map, int offset, int length) {\r
+ if (offset + length > map.size)\r
+ throw new IllegalArgumentException("offset + length must be <= size: " + offset + " + " + length + " <= " + map.size);\r
+ int sizeNeeded = size + length - offset;\r
+ if (sizeNeeded >= keys.length) resize(Math.max(8, (int)(sizeNeeded * 1.75f)));\r
+ System.arraycopy(map.keys, offset, keys, size, length);\r
+ System.arraycopy(map.values, offset, values, size, length);\r
+ size += length;\r
+ }\r
+\r
+ /** Returns the value for the specified key. Note this does a .equals() comparison of each key in reverse order until the\r
+ * specified key is found. */\r
+ public V get (K key) {\r
+ Object[] keys = this.keys;\r
+ int i = size - 1;\r
+ if (key == null) {\r
+ for (; i >= 0; i--)\r
+ if (keys[i] == key) return values[i];\r
+ } else {\r
+ for (; i >= 0; i--)\r
+ if (key.equals(keys[i])) return values[i];\r
+ }\r
+ return null;\r
+ }\r
+\r
+ /** Returns the value for the specified key. Note this does a comparison of each key in reverse order until the specified key is\r
+ * found.\r
+ * @param identity If true, == comparison will be used. If false, .equals() comaparison will be used. */\r
+ public V get (K key, boolean identity) {\r
+ Object[] keys = this.keys;\r
+ int i = size - 1;\r
+ if (identity || key == null) {\r
+ for (; i >= 0; i--)\r
+ if (keys[i] == key) return values[i];\r
+ } else {\r
+ for (; i >= 0; i--)\r
+ if (key.equals(keys[i])) return values[i];\r
+ }\r
+ return null;\r
+ }\r
+\r
+ /** Returns the key for the specified value. Note this does a comparison of each value in reverse order until the specified\r
+ * value is found.\r
+ * @param identity If true, == comparison will be used. If false, .equals() comaparison will be used. */\r
+ public K getKey (V value, boolean identity) {\r
+ Object[] values = this.values;\r
+ int i = size - 1;\r
+ if (identity || values == null) {\r
+ for (; i >= 0; i--)\r
+ if (values[i] == values) return keys[i];\r
+ } else {\r
+ for (; i >= 0; i--)\r
+ if (values.equals(values[i])) return keys[i];\r
+ }\r
+ return null;\r
+ }\r
+\r
+ public K getKeyAt (int index) {\r
+ if (index >= size) throw new IndexOutOfBoundsException(String.valueOf(index));\r
+ return keys[index];\r
+ }\r
+\r
+ public V getValueAt (int index) {\r
+ if (index >= size) throw new IndexOutOfBoundsException(String.valueOf(index));\r
+ return values[index];\r
+ }\r
+\r
+ public void setKey (int index, K key) {\r
+ if (index >= size) throw new IndexOutOfBoundsException(String.valueOf(index));\r
+ keys[index] = key;\r
+ }\r
+\r
+ public void setValue (int index, V value) {\r
+ if (index >= size) throw new IndexOutOfBoundsException(String.valueOf(index));\r
+ values[index] = value;\r
+ }\r
+\r
+ public void insert (int index, K key, V value) {\r
+ if (size == keys.length) resize(Math.max(8, (int)(size * 1.75f)));\r
+ if (ordered) {\r
+ System.arraycopy(keys, index, keys, index + 1, size - index);\r
+ System.arraycopy(values, index, values, index + 1, size - index);\r
+ } else {\r
+ keys[size] = keys[index];\r
+ values[size] = values[index];\r
+ }\r
+ size++;\r
+ keys[index] = key;\r
+ values[index] = value;\r
+ }\r
+\r
+ /** @param identity If true, == comparison will be used. If false, .equals() comaparison will be used. */\r
+ public boolean containsKey (K key, boolean identity) {\r
+ K[] keys = this.keys;\r
+ int i = size - 1;\r
+ if (identity || key == null) {\r
+ while (i >= 0)\r
+ if (keys[i--] == key) return true;\r
+ } else {\r
+ while (i >= 0)\r
+ if (key.equals(keys[i--])) return true;\r
+ }\r
+ return false;\r
+ }\r
+\r
+ /** @param identity If true, == comparison will be used. If false, .equals() comaparison will be used. */\r
+ public boolean containsValue (V value, boolean identity) {\r
+ V[] values = this.values;\r
+ int i = size - 1;\r
+ if (identity || value == null) {\r
+ while (i >= 0)\r
+ if (values[i--] == value) return true;\r
+ } else {\r
+ while (i >= 0)\r
+ if (value.equals(values[i--])) return true;\r
+ }\r
+ return false;\r
+ }\r
+\r
+ public int indexOfKey (K key, boolean identity) {\r
+ Object[] keys = this.keys;\r
+ if (identity || key == null) {\r
+ for (int i = 0, n = size; i < n; i++)\r
+ if (keys[i] == key) return i;\r
+ } else {\r
+ for (int i = 0, n = size; i < n; i++)\r
+ if (key.equals(keys[i])) return i;\r
+ }\r
+ return -1;\r
+ }\r
+\r
+ public int indexOfValue (V value, boolean identity) {\r
+ Object[] values = this.values;\r
+ if (identity || value == null) {\r
+ for (int i = 0, n = size; i < n; i++)\r
+ if (values[i] == value) return i;\r
+ } else {\r
+ for (int i = 0, n = size; i < n; i++)\r
+ if (value.equals(values[i])) return i;\r
+ }\r
+ return -1;\r
+ }\r
+\r
+ public V removeKey (K key, boolean identity) {\r
+ Object[] keys = this.keys;\r
+ if (identity || key == null) {\r
+ for (int i = 0, n = size; i < n; i++) {\r
+ if (keys[i] == key) {\r
+ V value = values[i];\r
+ removeIndex(i);\r
+ return value;\r
+ }\r
+ }\r
+ } else {\r
+ for (int i = 0, n = size; i < n; i++) {\r
+ if (key.equals(keys[i])) {\r
+ V value = values[i];\r
+ removeIndex(i);\r
+ return value;\r
+ }\r
+ }\r
+ }\r
+ return null;\r
+ }\r
+\r
+ public boolean removeValue (V value, boolean identity) {\r
+ Object[] values = this.values;\r
+ if (identity || value == null) {\r
+ for (int i = 0, n = size; i < n; i++) {\r
+ if (values[i] == value) {\r
+ removeIndex(i);\r
+ return true;\r
+ }\r
+ }\r
+ } else {\r
+ for (int i = 0, n = size; i < n; i++) {\r
+ if (value.equals(values[i])) {\r
+ removeIndex(i);\r
+ return true;\r
+ }\r
+ }\r
+ }\r
+ return false;\r
+ }\r
+\r
+ /** Removes and returns the key/values pair at the specified index. */\r
+ public void removeIndex (int index) {\r
+ if (index >= size) throw new IndexOutOfBoundsException(String.valueOf(index));\r
+ Object[] keys = this.keys;\r
+ size--;\r
+ if (ordered) {\r
+ System.arraycopy(keys, index + 1, keys, index, size - index);\r
+ System.arraycopy(values, index + 1, values, index, size - index);\r
+ } else {\r
+ keys[index] = keys[size];\r
+ values[index] = values[size];\r
+ }\r
+ keys[size] = null;\r
+ values[size] = null;\r
+ }\r
+\r
+ /** Returns the last key. */\r
+ public K peekKey () {\r
+ return keys[size - 1];\r
+ }\r
+\r
+ /** Returns the last value. */\r
+ public V peekValue () {\r
+ return values[size - 1];\r
+ }\r
+\r
+ public void clear () {\r
+ K[] keys = this.keys;\r
+ V[] values = this.values;\r
+ for (int i = 0, n = size; i < n; i++) {\r
+ keys[i] = null;\r
+ values[i] = null;\r
+ }\r
+ size = 0;\r
+ }\r
+\r
+ /** Reduces the size of the backing arrays to the size of the actual number of entries. This is useful to release memory when\r
+ * many items have been removed, or if it is known that more entries will not be added. */\r
+ public void shrink () {\r
+ resize(size);\r
+ }\r
+\r
+ /** Increases the size of the backing arrays to acommodate the specified number of additional entries. Useful before adding many\r
+ * entries to avoid multiple backing array resizes. */\r
+ public void ensureCapacity (int additionalCapacity) {\r
+ int sizeNeeded = size + additionalCapacity;\r
+ if (sizeNeeded >= keys.length) resize(Math.max(8, sizeNeeded));\r
+ }\r
+\r
+ protected void resize (int newSize) {\r
+ K[] newKeys = (K[])new Object[newSize];\r
+ System.arraycopy(keys, 0, newKeys, 0, Math.min(keys.length, newKeys.length));\r
+ this.keys = newKeys;\r
+\r
+ V[] newValues = (V[])new Object[newSize];\r
+ System.arraycopy(values, 0, newValues, 0, Math.min(values.length, newValues.length));\r
+ this.values = newValues;\r
+ }\r
+\r
+ public void reverse () {\r
+ for (int i = 0, lastIndex = size - 1, n = size / 2; i < n; i++) {\r
+ int ii = lastIndex - i;\r
+ K tempKey = keys[i];\r
+ keys[i] = keys[ii];\r
+ keys[ii] = tempKey;\r
+\r
+ V tempValue = values[i];\r
+ values[i] = values[ii];\r
+ values[ii] = tempValue;\r
+ }\r
+ }\r
+\r
+ public void shuffle () {\r
+ for (int i = size - 1; i >= 0; i--) {\r
+ int ii = MathUtils.random(i);\r
+ K tempKey = keys[i];\r
+ keys[i] = keys[ii];\r
+ keys[ii] = tempKey;\r
+\r
+ V tempValue = values[i];\r
+ values[i] = values[ii];\r
+ values[ii] = tempValue;\r
+ }\r
+ }\r
+\r
+ /** Reduces the size of the arrays to the specified size. If the arrays are already smaller than the specified size, no action\r
+ * is taken. */\r
+ public void truncate (int newSize) {\r
+ if (size <= newSize) return;\r
+ for (int i = newSize; i < size; i++) {\r
+ keys[i] = null;\r
+ values[i] = null;\r
+ }\r
+ size = newSize;\r
+ }\r
+\r
+ public String toString () {\r
+ if (size == 0) return "{}";\r
+ K[] keys = this.keys;\r
+ V[] values = this.values;\r
+ StringBuilder buffer = new StringBuilder(32);\r
+ buffer.append('{');\r
+ buffer.append(keys[0]);\r
+ buffer.append('=');\r
+ buffer.append(values[0]);\r
+ for (int i = 1; i < size; i++) {\r
+ buffer.append(", ");\r
+ buffer.append(keys[i]);\r
+ buffer.append('=');\r
+ buffer.append(values[i]);\r
+ }\r
+ buffer.append('}');\r
+ return buffer.toString();\r
+ }\r
+}\r
--- /dev/null
+/*******************************************************************************\r
+ * Copyright 2011 See AUTHORS file.\r
+ * \r
+ * Licensed under the Apache License, Version 2.0 (the "License");\r
+ * you may not use this file except in compliance with the License.\r
+ * You may obtain a copy of the License at\r
+ * \r
+ * http://www.apache.org/licenses/LICENSE-2.0\r
+ * \r
+ * Unless required by applicable law or agreed to in writing, software\r
+ * distributed under the License is distributed on an "AS IS" BASIS,\r
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ * See the License for the specific language governing permissions and\r
+ * limitations under the License.\r
+ ******************************************************************************/\r
+\r
+package com.badlogic.gdx.utils;\r
+\r
+/** Indicates an error during serialization due to misconfiguration or during deserialization due to invalid input data.\r
+ * @author Nathan Sweet <misc@n4te.com> */\r
+public class SerializationException extends RuntimeException {\r
+ private StringBuffer trace;\r
+\r
+ public SerializationException () {\r
+ super();\r
+ }\r
+\r
+ public SerializationException (String message, Throwable cause) {\r
+ super(message, cause);\r
+ }\r
+\r
+ public SerializationException (String message) {\r
+ super(message);\r
+ }\r
+\r
+ public SerializationException (Throwable cause) {\r
+ super("", cause);\r
+ }\r
+\r
+ /** Returns true if any of the exceptions that caused this exception are of the specified type. */\r
+ public boolean causedBy (Class type) {\r
+ return causedBy(this, type);\r
+ }\r
+\r
+ private boolean causedBy (Throwable ex, Class type) {\r
+ Throwable cause = ex.getCause();\r
+ if (cause == null || cause == ex) return false;\r
+ return false;\r
+ }\r
+\r
+ public String getMessage () {\r
+ if (trace == null) return super.getMessage();\r
+ StringBuffer buffer = new StringBuffer(512);\r
+ buffer.append(super.getMessage());\r
+ if (buffer.length() > 0) buffer.append('\n');\r
+ buffer.append("Serialization trace:");\r
+ buffer.append(trace);\r
+ return buffer.toString();\r
+ }\r
+\r
+ /** Adds information to the exception message about where in the the object graph serialization failure occurred. Serializers\r
+ * can catch {@link SerializationException}, add trace information, and rethrow the exception. */\r
+ public void addTrace (String info) {\r
+ if (info == null) throw new IllegalArgumentException("info cannot be null.");\r
+ if (trace == null) trace = new StringBuffer(512);\r
+ trace.append('\n');\r
+ trace.append(info);\r
+ }\r
+}\r
--- /dev/null
+package com.badlogic.gdx.utils;\r
+\r
+/**\r
+ * Wrapper around System.nanoTime() and System.currentTimeMillis(). Use this\r
+ * if you want to be compatible across all platforms!\r
+ * @author mzechner\r
+ *\r
+ */\r
+public class TimeUtils {\r
+ /**\r
+ * @return The current value of the system timer, in nanoseconds.\r
+ */\r
+ public static long nanoTime() {\r
+ return System.currentTimeMillis() * 1000000l;\r
+ }\r
+ \r
+ /**\r
+ * @return the difference, measured in milliseconds, between the current time and midnight, January 1, 1970 UTC.\r
+ */\r
+ public static long millis() {\r
+ return System.currentTimeMillis();\r
+ }\r
+}\r
-<?xml version="1.0" encoding="UTF-8"?>\r
-<module rename-to='com.badlogic.gdx'>\r
-\r
- <source path="gdx">\r
- <!-- main interfaces/classes -->\r
- <include name="**/Application.java"/>\r
- <include name="**/ApplicationListener.java"/>\r
- <include name="**/ApplicationAdapter.java"/>\r
- <include name="**/Audio.java"/>\r
- <include name="**/Files.java"/>\r
- <include name="**/Game.java"/>\r
- <include name="**/Gdx.java"/>\r
- <include name="**/Graphics.java"/>\r
- <include name="**/Input.java"/>\r
- <include name="**/InputAdapter.java"/>\r
- <include name="**/InputMultiplexer.java"/>\r
- <include name="**/InputProcessor.java"/>\r
- <include name="**/Preferences.java"/>\r
- <include name="**/Screen.java"/>\r
- <include name="**/Version.java"/>\r
- \r
- <!-- audio interfaces/classes -->\r
- <include name="**/audio/AudioDevice.java"/>\r
- <include name="**/audio/AudioRecorder.java"/>\r
- <include name="**/audio/Music.java"/>\r
- <include name="**/audio/Sound.java"/>\r
- \r
- <!-- files interfaces/classes -->\r
-<!-- <include name="**/FileHandle.java"/> -->\r
-<!-- <include name="**/FileHandleStream.java"/> -->\r
- \r
- <!-- graphics interfaces/classes -->\r
- <include name="**/graphics/FPSLogger.java"/>\r
- <include name="**/graphics/Camera.java"/>\r
- <include name="**/graphics/Color.java"/>\r
- <include name="**/graphics/GL10.java"/>\r
- <include name="**/graphics/GL11.java"/>\r
- <include name="**/graphics/GL20.java"/>\r
- <include name="**/graphics/GLCommon.java"/>\r
- <include name="**/graphics/GLU.java"/>\r
- <include name="**/graphics/Mesh.java"/>\r
- <include name="**/graphics/OrthographicCamera.java"/>\r
- <include name="**/graphics/PerspectiveCamera.java"/>\r
- <include name="**/graphics/TextureData.java"/>\r
- <include name="**/graphics/VertexAttribute.java"/>\r
- <include name="**/graphics/VertexAttributes.java"/>\r
- <include name="**/graphics/glutils/PixmapTextureData.java"/>\r
- <include name="**/graphics/glutils/FileTextureData.java"/>\r
- <include name="**/graphics/glutils/FrameBuffer.java"/>\r
- <include name="**/graphics/glutils/IndexBufferObjectSubData.java"/>\r
- <include name="**/graphics/glutils/IndexData.java"/>\r
- <include name="**/graphics/glutils/VertexBufferObjectSubData.java"/>\r
- <include name="**/graphics/glutils/VertexData.java"/>\r
- <include name="**/graphics/glutils/ShapeRenderer.java"/>\r
- <include name="**/graphics/glutils/ImmediateModeRenderer.java"/>\r
- <include name="**/graphics/glutils/ImmediateModeRenderer10.java"/>\r
- <include name="**/graphics/glutils/ImmediateModeRenderer20.java"/>\r
- \r
- <include name="**/graphics/g2d/Animation.java"/>\r
- <include name="**/graphics/g2d/PixmapPacker.java"/>\r
- <include name="**/graphics/g2d/Sprite.java"/>\r
- <include name="**/graphics/g2d/SpriteBatch.java"/>\r
- <include name="**/graphics/g2d/SpriteCache.java"/>\r
- <include name="**/graphics/g2d/TextureRegion.java"/>\r
- <include name="**/graphics/g2d/BitmapFont.java"/>\r
- <include name="**/graphics/g2d/BitmapFontCache.java"/>\r
- <include name="**/graphics/g2d/TextureAtlas.java"/>\r
- \r
- <include name="**/graphics/g3d/decals/**"/>\r
- <include name="**/loaders/obj/ObjLoader.java"/>\r
- \r
- <!-- assets -->\r
- <include name="**/assets/AssetDescriptor.java"/>\r
- <include name="**/assets/AssetErrorListener.java"/>\r
- <include name="**/assets/AssetLoaderParameters.java"/>\r
- <include name="**/assets/RefCountedContainer.java"/>\r
- <include name="**/assets/loaders/AssetLoader.java"/>\r
- <include name="**/assets/loaders/FileHandleResolver.java"/>\r
- <include name="**/assets/loaders/resolvers/InternalFileHandleResolver.java"/>\r
- \r
-\r
- <!-- math package -->\r
- <include name="**/math/**"/>\r
- <exclude name="**/math/Matrix4.java"/>\r
- \r
- <!-- utils interfaces/classes -->\r
- <include name="**/utils/Disposable.java"/>\r
- <include name="**/utils/GdxRuntimeException.java"/>\r
- <include name="**/utils/Sort.java"/>\r
- <include name="**/utils/ComparableTimSort.java"/>\r
- <include name="**/utils/TimSort.java"/>\r
- <include name="**/utils/ObjectMap.java"/>\r
- <include name="**/utils/ObjectIntMap.java"/>\r
- <include name="**/utils/IntMap.java"/>\r
- <include name="**/utils/IntArray.java"/>\r
- <include name="**/utils/LongMap.java"/>\r
- <include name="**/utils/LongArray.java"/>\r
- <include name="**/utils/FloatArray.java"/>\r
- <include name="**/utils/Pool.java"/>\r
- <include name="**/utils/OrderedMap.java"/>\r
- <include name="**/utils/SortedIntList.java"/>\r
- </source>\r
-</module>\r
+<?xml version="1.0" encoding="UTF-8"?>
+<module rename-to="com.badlogic.gdx">
+ <source path="gdx">
+ <include name="scenes/scene2d/interpolators/AccelerateDecelerateInterpolator.java"/>
+ <include name="scenes/scene2d/interpolators/AccelerateInterpolator.java"/>
+ <include name="scenes/scene2d/Action.java"/>
+ <include name="scenes/scene2d/actions/ActionResetingPool.java"/>
+ <include name="scenes/scene2d/Actor.java"/>
+ <include name="graphics/g3d/Animation.java"/>
+ <include name="scenes/scene2d/AnimationAction.java"/>
+ <include name="graphics/g3d/Animator.java"/>
+ <include name="scenes/scene2d/interpolators/AnticipateInterpolator.java"/>
+ <include name="Application.java"/>
+ <include name="ApplicationAdapter.java"/>
+ <include name="ApplicationListener.java"/>
+ <include name="assets/AssetDescriptor.java"/>
+ <include name="assets/AssetErrorListener.java"/>
+ <include name="assets/loaders/AssetLoader.java"/>
+ <include name="assets/AssetLoaderParameters.java"/>
+ <include name="assets/loaders/AsynchronousAssetLoader.java"/>
+ <include name="Audio.java"/>
+ <include name="audio/AudioDevice.java"/>
+ <include name="audio/AudioRecorder.java"/>
+ <include name="utils/Base64Coder.java"/>
+ <include name="src/com/esotericsoftware/tablelayout/BaseTableLayout.java"/>
+ <include name="utils/BinaryHeap.java"/>
+ <include name="graphics/g2d/BitmapFont.java"/>
+ <include name="graphics/g2d/BitmapFontCache.java"/>
+ <include name="assets/loaders/BitmapFontLoader.java"/>
+ <include name="utils/BooleanArray.java"/>
+ <include name="math/collision/BoundingBox.java"/>
+ <include name="graphics/Camera.java"/>
+ <include name="graphics/g3d/decals/CameraGroupStrategy.java"/>
+ <include name="math/CatmullRomSpline.java"/>
+ <include name="src/com/esotericsoftware/tablelayout/Cell.java"/>
+ <include name="utils/CharArray.java"/>
+ <include name="math/Circle.java"/>
+ <include name="graphics/Color.java"/>
+ <include name="utils/ComparableTimSort.java"/>
+ <include name="scenes/scene2d/CompositeAction.java"/>
+ <include name="scenes/scene2d/Cullable.java"/>
+ <include name="graphics/g3d/decals/Decal.java"/>
+ <include name="graphics/g3d/decals/DecalBatch.java"/>
+ <include name="graphics/g3d/decals/DecalMaterial.java"/>
+ <include name="scenes/scene2d/interpolators/DecelerateInterpolator.java"/>
+ <include name="graphics/g3d/decals/DefaultGroupStrategy.java"/>
+ <include name="scenes/scene2d/actions/Delay.java"/>
+ <include name="utils/Disposable.java"/>
+ <include name="math/EarClippingTriangulator.java"/>
+ <include name="graphics/g2d/EmptyNinePatch.java"/>
+ <include name="assets/loaders/resolvers/ExternalFileHandleResolver.java"/>
+ <include name="graphics/FPSLogger.java"/>
+ <include name="scenes/scene2d/actions/FadeIn.java"/>
+ <include name="scenes/scene2d/actions/FadeOut.java"/>
+ <include name="scenes/scene2d/actions/FadeTo.java"/>
+ <include name="assets/loaders/FileHandleResolver.java"/>
+ <include name="Files.java"/>
+ <include name="utils/FloatArray.java"/>
+ <include name="scenes/scene2d/actions/Forever.java"/>
+ <include name="graphics/glutils/FrameBuffer.java"/>
+ <include name="math/Frustum.java"/>
+ <include name="graphics/GL10.java"/>
+ <include name="graphics/GL11.java"/>
+ <include name="graphics/GL20.java"/>
+ <include name="graphics/GLCommon.java"/>
+ <include name="graphics/GLU.java"/>
+ <include name="Game.java"/>
+ <include name="Gdx.java"/>
+ <include name="utils/GdxRuntimeException.java"/>
+ <include name="assets/loaders/GenericLoader.java"/>
+ <include name="input/GestureDetector.java"/>
+ <include name="Graphics.java"/>
+ <include name="scenes/scene2d/Group.java"/>
+ <include name="graphics/g3d/decals/GroupPlug.java"/>
+ <include name="graphics/g3d/decals/GroupStrategy.java"/>
+ <include name="utils/IdentityMap.java"/>
+ <include name="graphics/glutils/ImmediateModeRenderer.java"/>
+ <include name="graphics/glutils/ImmediateModeRenderer10.java"/>
+ <include name="graphics/glutils/ImmediateModeRenderer20.java"/>
+ <include name="graphics/glutils/IndexBufferObjectSubData.java"/>
+ <include name="graphics/glutils/IndexData.java"/>
+ <include name="Input.java"/>
+ <include name="InputAdapter.java"/>
+ <include name="InputMultiplexer.java"/>
+ <include name="InputProcessor.java"/>
+ <include name="utils/IntArray.java"/>
+ <include name="utils/IntMap.java"/>
+ <include name="assets/loaders/resolvers/InternalFileHandleResolver.java"/>
+ <include name="math/Interpolation.java"/>
+ <include name="scenes/scene2d/Interpolator.java"/>
+ <include name="math/Intersector.java"/>
+ <include name="utils/JsonReader.java"/>
+ <include name="graphics/g3d/keyframed/Keyframe.java"/>
+ <include name="graphics/g3d/keyframed/KeyframeAnimation.java"/>
+ <include name="graphics/g3d/keyframed/KeyframeAnimator.java"/>
+ <include name="graphics/g3d/keyframed/KeyframedModel.java"/>
+ <include name="scenes/scene2d/Layout.java"/>
+ <include name="scenes/scene2d/interpolators/LinearInterpolator.java"/>
+ <include name="utils/Logger.java"/>
+ <include name="utils/LongArray.java"/>
+ <include name="utils/LongMap.java"/>
+ <include name="graphics/g3d/loaders/md5/MD5Animation.java"/>
+ <include name="graphics/g3d/loaders/md5/MD5AnimationInfo.java"/>
+ <include name="graphics/g3d/loaders/md5/MD5Animator.java"/>
+ <include name="graphics/g3d/loaders/md5/MD5Jni.java"/>
+ <include name="graphics/g3d/loaders/md5/MD5Joints.java"/>
+ <include name="graphics/g3d/loaders/md5/MD5Loader.java"/>
+ <include name="graphics/g3d/loaders/md5/MD5Mesh.java"/>
+ <include name="graphics/g3d/loaders/md5/MD5Model.java"/>
+ <include name="graphics/g3d/loaders/md5/MD5Quaternion.java"/>
+ <include name="graphics/g3d/loaders/md5/MD5Renderer.java"/>
+ <include name="graphics/g3d/Material.java"/>
+ <include name="math/MathUtils.java"/>
+ <include name="math/Matrix3.java"/>
+ <include name="graphics/Mesh.java"/>
+ <include name="graphics/glutils/MipMapGenerator.java"/>
+ <include name="graphics/g3d/loaders/ModelLoaderOld.java"/>
+ <include name="scenes/scene2d/actions/MoveBy.java"/>
+ <include name="scenes/scene2d/actions/MoveTo.java"/>
+ <include name="audio/Music.java"/>
+ <include name="assets/loaders/MusicLoader.java"/>
+ <include name="graphics/g2d/NinePatch.java"/>
+ <include name="graphics/g3d/loaders/obj/ObjLoader.java"/>
+ <include name="utils/ObjectIntMap.java"/>
+ <include name="utils/ObjectMap.java"/>
+ <include name="scenes/scene2d/OnActionCompleted.java"/>
+ <include name="utils/OrderedMap.java"/>
+ <include name="graphics/OrthographicCamera.java"/>
+ <include name="scenes/scene2d/interpolators/OvershootInterpolator.java"/>
+ <include name="scenes/scene2d/actions/Parallel.java"/>
+ <include name="src/com/esotericsoftware/tablelayout/ParseException.java"/>
+ <include name="graphics/g2d/ParticleEffectPool.java"/>
+ <include name="graphics/g2d/ParticleEmitter.java"/>
+ <include name="graphics/PerspectiveCamera.java"/>
+ <include name="assets/loaders/PixmapLoader.java"/>
+ <include name="graphics/g2d/PixmapPacker.java"/>
+ <include name="graphics/glutils/PixmapTextureData.java"/>
+ <include name="math/Plane.java"/>
+ <include name="graphics/g3d/decals/PluggableGroupStrategy.java"/>
+ <include name="math/Polygon.java"/>
+ <include name="utils/Pool.java"/>
+ <include name="utils/PooledLinkedList.java"/>
+ <include name="Preferences.java"/>
+ <include name="math/Quaternion.java"/>
+ <include name="math/collision/Ray.java"/>
+ <include name="math/Rectangle.java"/>
+ <include name="assets/RefCountedContainer.java"/>
+ <include name="scenes/scene2d/actions/Remove.java"/>
+ <include name="scenes/scene2d/actions/Repeat.java"/>
+ <include name="scenes/scene2d/actions/RotateBy.java"/>
+ <include name="scenes/scene2d/actions/RotateTo.java"/>
+ <include name="scenes/scene2d/actions/ScaleTo.java"/>
+ <include name="utils/Scaling.java"/>
+ <include name="Screen.java"/>
+ <include name="math/collision/Segment.java"/>
+ <include name="scenes/scene2d/actions/Sequence.java"/>
+ <include name="graphics/glutils/ShapeRenderer.java"/>
+ <include name="graphics/g3d/decals/SimpleOrthoGroupStrategy.java"/>
+ <include name="graphics/g2d/tiled/SimpleTileAtlas.java"/>
+ <include name="utils/Sort.java"/>
+ <include name="utils/SortedIntList.java"/>
+ <include name="audio/Sound.java"/>
+ <include name="assets/loaders/SoundLoader.java"/>
+ <include name="math/collision/Sphere.java"/>
+ <include name="graphics/g2d/Sprite.java"/>
+ <include name="graphics/g2d/SpriteBatch.java"/>
+ <include name="graphics/g2d/SpriteCache.java"/>
+ <include name="scenes/scene2d/Stage.java"/>
+ <include name="assets/loaders/SynchronousAssetLoader.java"/>
+ <include name="src/com/esotericsoftware/tablelayout/TableLayoutParser.java"/>
+ <include name="scenes/scene2d/TemporalAction.java"/>
+ <include name="graphics/g2d/TextureAtlas.java"/>
+ <include name="assets/loaders/TextureAtlasLoader.java"/>
+ <include name="graphics/TextureData.java"/>
+ <include name="graphics/TextureDict.java"/>
+ <include name="graphics/TextureRef.java"/>
+ <include name="graphics/g2d/TextureRegion.java"/>
+ <include name="graphics/g2d/tiled/TileAtlas.java"/>
+ <include name="assets/loaders/TileAtlasLoader.java"/>
+ <include name="graphics/g2d/tiled/TileMapRenderer.java"/>
+ <include name="graphics/g2d/tiled/TileSet.java"/>
+ <include name="graphics/g2d/tiled/TiledLayer.java"/>
+ <include name="graphics/g2d/tiled/TiledMap.java"/>
+ <include name="graphics/g2d/tiled/TiledObject.java"/>
+ <include name="graphics/g2d/tiled/TiledObjectGroup.java"/>
+ <include name="utils/TimSort.java"/>
+ <include name="src/com/esotericsoftware/tablelayout/Toolkit.java"/>
+ <include name="math/Vector2.java"/>
+ <include name="math/Vector3.java"/>
+ <include name="Version.java"/>
+ <include name="graphics/VertexAttribute.java"/>
+ <include name="graphics/VertexAttributes.java"/>
+ <include name="graphics/glutils/VertexBufferObjectSubData.java"/>
+ <include name="graphics/glutils/VertexData.java"/>
+ <include name="math/WindowedMean.java"/>
+ <include name="utils/XmlReader.java"/>
+ <include name="utils/XmlWriter.java"/>
+ <include name="graphics/g2d/Animation.java"/>
+ <include name="graphics/g3d/Animation.java"/>
+ </source>
+</module>
import com.badlogic.gdx.utils.Array;\r
import com.badlogic.gdx.utils.GdxRuntimeException;\r
import com.badlogic.gdx.utils.Logger;\r
+import com.badlogic.gdx.utils.TimeUtils;\r
\r
/** Responsible for loading an asset through an {@link AssetLoader} based on an {@link AssetDescriptor}. Implements\r
* {@link Callable} and is used with an {@link ExecutorService threadpool} to load parts of an asset asynchronously if the asset is\r
this.assetDesc = assetDesc;\r
this.loader = loader;\r
this.threadPool = threadPool;\r
- startTime = manager.log.getLevel() == Logger.DEBUG ? System.nanoTime() : 0;\r
+ startTime = manager.log.getLevel() == Logger.DEBUG ? TimeUtils.nanoTime() : 0;\r
}\r
\r
/** Loads parts of the asset asynchronously if the loader is an {@link AsynchronousAssetLoader}. */\r
import com.badlogic.gdx.utils.Logger;\r
import com.badlogic.gdx.utils.ObjectIntMap;\r
import com.badlogic.gdx.utils.ObjectMap;\r
+import com.badlogic.gdx.utils.TimeUtils;\r
\r
public class AssetManager implements Disposable {\r
final ObjectMap<Class, ObjectMap<String, RefCountedContainer>> assets = new ObjectMap<Class, ObjectMap<String, RefCountedContainer>>();\r
task.assetDesc.params.loadedCallback.finishedLoading(this, task.assetDesc.fileName, task.assetDesc.type);\r
}\r
\r
- long endTime = System.nanoTime();\r
+ long endTime = TimeUtils.nanoTime();\r
log.debug("Loaded: " + (endTime - task.startTime) / 1000000f + "ms " + task.assetDesc);\r
}\r
\r
numVertices = vertices.length;\r
numIndices = indices.length;\r
if (!cached) {\r
- k.vertices[m] = new float[vertices.length];\r
- k.vertices[m] = vertices.clone();\r
- k.indices[m] = new short[indices.length];\r
- k.indices[m] = indices.clone();\r
+ k.vertices[m] = clone(vertices);\r
+ k.indices[m] = clone(indices);\r
}\r
\r
if (target[m] == null) {\r
return a;\r
}\r
\r
+ private short[] clone (short[] indices) {\r
+ short[] tmp = new short[indices.length];\r
+ System.arraycopy(indices, 0, tmp, 0, indices.length);\r
+ return tmp;\r
+ }\r
+\r
+ private float[] clone (float[] vertices) {\r
+ float[] tmp = new float[vertices.length];\r
+ System.arraycopy(vertices, 0, tmp, 0, vertices.length);\r
+ return tmp;\r
+ }\r
+\r
public void getJointData (int tagIndex, Vector3 pos, Quaternion orient) {\r
Keyframe kf = animator.getInterpolatedKeyframe();\r
pos.set(kf.taggedJointPos[tagIndex]);\r
\r
public class MD5Jni {\r
public static native void calculateVertices (float[] joints, float[] weights, float[] verticesIn, float[] verticesOut,\r
- int numVertices, int vstride, int wstride); /*\r
+ int numVertices, int vstride, int wstride)/*-{ }-*/; /*\r
for (int vertexOffset = 2, k = 0; vertexOffset < numVertices; vertexOffset += vstride) {\r
float finalX = 0;\r
float finalY = 0;\r
import com.badlogic.gdx.Gdx;\r
import com.badlogic.gdx.InputAdapter;\r
import com.badlogic.gdx.math.Vector2;\r
+import com.badlogic.gdx.utils.TimeUtils;\r
\r
public class GestureDetector extends InputAdapter {\r
public static interface GestureListener {\r
panning = false;\r
if (inTapSquare & !longPressFired) {\r
// handle taps\r
- if (System.nanoTime() - lastTapTime > tapCountInterval) tapCount = 0;\r
+ if (TimeUtils.nanoTime() - lastTapTime > tapCountInterval) tapCount = 0;\r
tapCount++;\r
- lastTapTime = System.nanoTime();\r
+ lastTapTime = TimeUtils.nanoTime();\r
gestureStartTime = 0;\r
return listener.tap(tapSquareCenterX, tapSquareCenterY, tapCount);\r
} else if (pinching) {\r
* @return whether the user touched the screen for as much or more than the given duration. */\r
public boolean isLongPressed (float duration) {\r
if (gestureStartTime == 0) return false;\r
- return System.nanoTime() - gestureStartTime > (long)(duration * 1000000000l);\r
+ return TimeUtils.nanoTime() - gestureStartTime > (long)(duration * 1000000000l);\r
}\r
\r
public boolean isPanning () {\r
\r
@Override\r
public String toString () {\r
- String name = this.name != null ? this.name : getClass().getSimpleName();\r
+ String name = this.name != null ? this.name : getClass().getName();\r
if (name.equals("")) name = getClass().getName();\r
return name + " pos=" + x + "," + y + " origin=" + originX + "," + originY + " size=" + width + "," + height;\r
}\r
import com.badlogic.gdx.scenes.scene2d.Group;\r
import com.badlogic.gdx.scenes.scene2d.ui.utils.Clipboard;\r
import com.badlogic.gdx.utils.FloatArray;\r
+import com.badlogic.gdx.utils.TimeUtils;\r
\r
/** A single-line text input field.\r
* <p>\r
}\r
\r
private void blink () {\r
- long time = System.nanoTime();\r
+ long time = TimeUtils.nanoTime();\r
if ((time - lastBlink) / 1000000000.0f > blinkTime) {\r
cursorOn = !cursorOn;\r
lastBlink = time;\r
public class Base64Coder {\r
\r
// The line separator string of the operating system.\r
- private static final String systemLineSeparator = System.getProperty("line.separator");\r
+ private static final String systemLineSeparator = "\n";\r
\r
// Mapping table from 6-bit nibbles to Base64 characters.\r
private static char[] map1 = new char[64];\r
--- /dev/null
+\r
+package com.badlogic.gdx.utils;\r
+\r
+import java.io.IOException;\r
+import java.io.StringWriter;\r
+import java.util.HashMap;\r
+import java.util.HashSet;\r
+import java.util.Map;\r
+import java.util.Set;\r
+import java.util.TreeMap;\r
+\r
+import com.badlogic.gdx.files.FileHandle;\r
+\r
+/** Generates the gdx.gwt.xml file by running through the gdx/src/ directory and cross-referencing it with the gdx-backends-gwt\r
+ * directory.\r
+ * @author mzechner */\r
+public class GwtModuleGenerator {\r
+ private static void gatherJavaFiles (FileHandle dir, Set<String> names, Map<String, FileHandle> fileHandles,\r
+ boolean recursive) {\r
+ if (dir.name().equals(".svn")) return;\r
+ FileHandle[] files = dir.list();\r
+ for (FileHandle file : files) {\r
+ if (file.isDirectory() && recursive) {\r
+ gatherJavaFiles(file, names, fileHandles, recursive);\r
+ } else {\r
+ if (file.extension().equals("java")) {\r
+ System.out.println(file.name());\r
+ if(names.contains(file.name())) System.out.println(file.name() + " duplicate!");\r
+ names.add(file.name());\r
+ fileHandles.put(file.name(), file);\r
+ }\r
+ }\r
+ }\r
+ }\r
+\r
+ public static void main (String[] args) throws IOException {\r
+ Set<String> excludes = new HashSet<String>();\r
+ Map<String, FileHandle> excludesHandles = new HashMap<String, FileHandle>();\r
+ System.out.println("Excludes -------------------------------------------------");\r
+ gatherJavaFiles(new FileHandle("../backends/gdx-backends-gwt/src/com/badlogic/gdx/backends/gwt/emu/com/badlogic/gdx"), excludes, excludesHandles, true);\r
+ System.out.println("#" + excludes.size());\r
+\r
+ // build and shared library loading utils\r
+ excludes.add("GdxBuild.java");\r
+ excludes.add("GdxNativesLoader.java");\r
+ excludes.add("GwtModuleGenerator.java");\r
+ excludes.add("SharedLibraryLoader.java");\r
+ \r
+ // native pixmap routines\r
+ excludes.add("Gdx2DPixmap.java");\r
+ excludes.add("PixmapIO.java");\r
+ excludes.add("ETC1.java");\r
+ excludes.add("ETC1TextureData.java");\r
+ excludes.add("ScreenUtils.java");\r
+\r
+ // asset manager related\r
+ excludes.add("ResolutionFileResolver.java"); // FIXME\r
+ excludes.add("SkinLoader.java");\r
+ \r
+ // remote input\r
+ excludes.add("RemoteInput.java");\r
+ excludes.add("RemoteSender.java");\r
+ \r
+ // box2d\r
+ excludes.add("ParticleEmitterBox2D.java");\r
+ gatherJavaFiles(new FileHandle("src/com/badlogic/gdx/physics/box2d"), excludes, excludesHandles, true);\r
+ \r
+ // tiled support\r
+ excludes.add("TiledLoader.java"); // FIXME?\r
+ excludes.add("TileMapRendererLoader.java"); // FIXME?\r
+ \r
+ // various utils\r
+ excludes.add("AtomicQueue.java");\r
+ excludes.add("LittleEndianInputStream.java");\r
+ excludes.add("PauseableThread.java");\r
+ excludes.add("Json.java");\r
+ excludes.add("JsonWriter.java");\r
+ \r
+ // scene2d ui package\r
+ gatherJavaFiles(new FileHandle("src/com/badlogic/gdx/scenes/scene2d/ui"), excludes, excludesHandles, true);\r
+\r
+ Set<String> includes = new HashSet<String>();\r
+ Map<String, FileHandle> includesHandles = new TreeMap<String, FileHandle>();\r
+ System.out.println("Includes -------------------------------------------------");\r
+ gatherJavaFiles(new FileHandle("src"), includes, includesHandles, true);\r
+ System.out.println("#" + includes.size());\r
+\r
+ for (String include : includes) {\r
+ if (!excludes.contains(include)) continue;\r
+ FileHandle includeFile = includesHandles.get(include);\r
+ FileHandle excludeFile = excludesHandles.get(include);\r
+ includesHandles.remove(include);\r
+ System.out.println("excluded '" + include + "'");\r
+ }\r
+ \r
+ System.out.println("diff: " + includesHandles.size());\r
+\r
+ StringWriter writer = new StringWriter();\r
+ writer.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");\r
+ XmlWriter builder = new XmlWriter(writer);\r
+ builder.element("module").attribute("rename-to", "com.badlogic.gdx");\r
+ builder.element("source").attribute("path", "gdx");\r
+ for(String include: includesHandles.keySet()) {\r
+ String name = includesHandles.get(include).path().replace("\\", "/").replace("src/com/badlogic/gdx/", "");\r
+ builder.element("include").attribute("name", name).pop();\r
+ }\r
+ // duplicate names...\r
+ builder.element("include").attribute("name", "graphics/g2d/Animation.java").pop();\r
+ builder.element("include").attribute("name", "graphics/g3d/Animation.java").pop();\r
+ builder.pop();\r
+ builder.pop();\r
+ System.out.println(writer);\r
+ \r
+ new FileHandle("src/com/badlogic/gdx.gwt.xml").writeString(writer.toString(), false);\r
+ }\r
+}\r
--- /dev/null
+package com.badlogic.gdx.utils;\r
+\r
+/**\r
+ * Wrapper around System.nanoTime() and System.currentTimeMillis(). Use this\r
+ * if you want to be compatible across all platforms!\r
+ * @author mzechner\r
+ *\r
+ */\r
+public class TimeUtils {\r
+ /**\r
+ * @return The current value of the system timer, in nanoseconds.\r
+ */\r
+ public static long nanoTime() {\r
+ return System.nanoTime();\r
+ }\r
+ \r
+ /**\r
+ * @return the difference, measured in milliseconds, between the current time and midnight, January 1, 1970 UTC.\r
+ */\r
+ public static long millis() {\r
+ return System.currentTimeMillis();\r
+ }\r
+}\r
-t:data/gwttestparams.txt
+t:assets.txt
i:data/43kJgl.jpg
i:data/alpha.png
i:data/animation.png
t:data/arial-15.fnt
i:data/arial-15_00.png
+b:data/arial.ttf
i:data/badlogic.jpg
i:data/badlogicsmall.jpg
i:data/black_marked_0.png
t:data/default.fnt
i:data/default.png
i:data/default_00.png
+b:data/DroidSansJapanese.ttf
+b:data/DroidSerif-Bold.ttf
+b:data/DroidSerif-Italic.ttf
+b:data/DroidSerif-Regular.ttf
i:data/egg.png
i:data/environment.jpg
t:data/font.fnt
i:data/font.png
i:data/group-debug.png
+t:data/gwttestparams.txt
i:data/isotile.png
t:data/issue_pack
i:data/jump.png
+t:data/jump.txt
i:data/layers.png
t:data/pack
i:data/pack1.png
i:data/rgb.png
t:data/scene.obj
t:data/scene2.obj
+b:data/shaders/batch.frag
+b:data/shaders/batch.vert
+b:data/shaders/convolution.frag
+b:data/shaders/default.frag
+b:data/shaders/default.vert
+b:data/shaders/depthtocolor.frag
t:data/shaders/flat-frag.glsl
t:data/shaders/flat-vert.glsl
t:data/shaders/flattex-frag.glsl
i:data/stones.jpg
i:data/sys.png
i:data/t8890.png
+b:data/test.etc1
+b:data/test.p
i:data/test.png
i:data/test3.png
i:data/test4.png
t:data/testpack
i:data/Textures1.png
i:data/tile.png
+b:data/tiledmap/alignment test.tmx
+b:data/tiledmap/margin spacing doctype test.tmx
t:data/tiledmap/perspective walls packfile
t:data/tiledmap/perspective walls test packfile
i:data/tiledmap/perspective walls test1.png
+b:data/tiledmap/perspective walls.tmx
i:data/tiledmap/perspective walls1.png
+b:data/tiledmap/tilemap csv.tmx
+b:data/tiledmap/tilemap gzip.tmx
+b:data/tiledmap/tilemap uncompressed.tmx
+b:data/tiledmap/tilemap xml.tmx
+b:data/tiledmap/tilemap zlib.tmx
t:data/tiledmap/tileset packfile
i:data/tiledmap/tileset1.png
t:data/tiledmap/tileset2 packfile
i:data/tiledmap/tmw-desert-spacing1.png
i:data/tiles.png
i:data/ui.png
+b:data/uiskin.json
i:data/uiskin.png
t:data/verdana39.fnt
i:data/verdana39.png
+b:data/walk1.md5anim
i:data/walkanim.png
i:data/wheel.png
+b:data/zfat.md5mesh
<classpathentry kind="src" path="src"/>\r
<classpathentry kind="con" path="com.google.gwt.eclipse.core.GWT_CONTAINER"/>\r
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>\r
- <classpathentry combineaccessrules="false" kind="src" path="/gdx"/>\r
<classpathentry combineaccessrules="false" kind="src" path="/gdx-backends-gwt"/>\r
+ <classpathentry combineaccessrules="false" kind="src" path="/gdx"/>\r
<classpathentry combineaccessrules="false" kind="src" path="/gdx-tests"/>\r
<classpathentry kind="output" path="war/WEB-INF/classes"/>\r
</classpath>\r
-#Thu Mar 15 17:56:44 CET 2012\r
+#Fri Mar 16 10:43:47 CET 2012\r
eclipse.preferences.version=1\r
entryPointModules=\r
filesCopiedToWebInfLib=gwt-servlet.jar\r
-gwtCompileSettings=PGd3dC1jb21waWxlLXNldHRpbmdzPjxsb2ctbGV2ZWw+SU5GTzwvbG9nLWxldmVsPjxvdXRwdXQtc3R5bGU+T0JGVVNDQVRFRDwvb3V0cHV0LXN0eWxlPjxleHRyYS1hcmdzPjwhW0NEQVRBW11dPjwvZXh0cmEtYXJncz48dm0tYXJncz48IVtDREFUQVstWG14NTEybV1dPjwvdm0tYXJncz48ZW50cnktcG9pbnQtbW9kdWxlPmNvbS5iYWRsb2dpYy5nZHgudGVzdHMuZ3d0LkdkeFRlc3RzR3d0PC9lbnRyeS1wb2ludC1tb2R1bGU+PC9nd3QtY29tcGlsZS1zZXR0aW5ncz4\=\r
+gwtCompileSettings=PGd3dC1jb21waWxlLXNldHRpbmdzPjxsb2ctbGV2ZWw+SU5GTzwvbG9nLWxldmVsPjxvdXRwdXQtc3R5bGU+T0JGVVNDQVRFRDwvb3V0cHV0LXN0eWxlPjxleHRyYS1hcmdzPjwhW0NEQVRBWy1zdHJpY3RdXT48L2V4dHJhLWFyZ3M+PHZtLWFyZ3M+PCFbQ0RBVEFbLVhteDUxMm1dXT48L3ZtLWFyZ3M+PGVudHJ5LXBvaW50LW1vZHVsZT5jb20uYmFkbG9naWMuZ2R4LnRlc3RzLmd3dC5HZHhUZXN0c0d3dDwvZW50cnktcG9pbnQtbW9kdWxlPjwvZ3d0LWNvbXBpbGUtc2V0dGluZ3M+\r
import com.badlogic.gdx.ApplicationListener;\r
import com.badlogic.gdx.backends.gwt.GwtApplication;\r
import com.badlogic.gdx.backends.gwt.GwtApplicationConfiguration;\r
-import com.badlogic.gdx.tests.gwt.GwtBinaryTest;\r
+import com.badlogic.gdx.tests.AlphaTest;\r
+import com.badlogic.gdx.tests.AnimationTest;\r
+import com.badlogic.gdx.tests.AssetManagerTest;\r
+import com.badlogic.gdx.tests.AtlasIssueTest;\r
+import com.badlogic.gdx.tests.BitmapFontAlignmentTest;\r
+import com.badlogic.gdx.tests.BitmapFontFlipTest;\r
+import com.badlogic.gdx.tests.BitmapFontTest;\r
+import com.badlogic.gdx.tests.BlitTest;\r
+import com.badlogic.gdx.tests.CustomShaderSpriteBatchTest;\r
+import com.badlogic.gdx.tests.DecalTest;\r
+import com.badlogic.gdx.tests.EdgeDetectionTest;\r
+import com.badlogic.gdx.tests.FilterPerformanceTest;\r
+import com.badlogic.gdx.tests.FrameBufferTest;\r
+import com.badlogic.gdx.tests.GestureDetectorTest;\r
+import com.badlogic.gdx.tests.IndexBufferObjectShaderTest;\r
+import com.badlogic.gdx.tests.IntegerBitmapFontTest;\r
+import com.badlogic.gdx.tests.InverseKinematicsTest;\r
+import com.badlogic.gdx.tests.IsoCamTest;\r
+import com.badlogic.gdx.tests.IsometricTileTest;\r
+import com.badlogic.gdx.tests.MatrixJNITest;\r
+import com.badlogic.gdx.tests.MeshShaderTest;\r
+import com.badlogic.gdx.tests.MultitouchTest;\r
+import com.badlogic.gdx.tests.MusicTest;\r
+import com.badlogic.gdx.tests.ParallaxTest;\r
+import com.badlogic.gdx.tests.ParticleEmitterTest;\r
+import com.badlogic.gdx.tests.PixelsPerInchTest;\r
+import com.badlogic.gdx.tests.RotationTest;\r
+import com.badlogic.gdx.tests.ShaderMultitextureTest;\r
+import com.badlogic.gdx.tests.ShapeRendererTest;\r
+import com.badlogic.gdx.tests.SimpleAnimationTest;\r
+import com.badlogic.gdx.tests.SimpleDecalTest;\r
+import com.badlogic.gdx.tests.SortedSpriteTest;\r
+import com.badlogic.gdx.tests.SpriteBatchShaderTest;\r
+import com.badlogic.gdx.tests.SpriteCacheOffsetTest;\r
+import com.badlogic.gdx.tests.SpriteCacheTest;\r
+import com.badlogic.gdx.tests.TextureAtlasTest;\r
+import com.badlogic.gdx.tests.VertexBufferObjectShaderTest;\r
+import com.badlogic.gdx.tests.YDownTest;\r
+import com.badlogic.gdx.tests.utils.GdxTest;\r
\r
public class GwtTestStarter extends GwtApplication {\r
-\r
+ GdxTest[] tests = {\r
+ new AlphaTest(),\r
+ new AnimationTest(),\r
+ new AssetManagerTest(),\r
+ new AtlasIssueTest(),\r
+ new BitmapFontAlignmentTest(),\r
+ new BitmapFontFlipTest(),\r
+ new BitmapFontTest(),\r
+ new BlitTest(),\r
+ new CustomShaderSpriteBatchTest(),\r
+ new DecalTest(),\r
+ new EdgeDetectionTest(),\r
+ new FilterPerformanceTest(),\r
+ new FrameBufferTest(),\r
+ new GestureDetectorTest(),\r
+ new IndexBufferObjectShaderTest(),\r
+ new IntegerBitmapFontTest(),\r
+ new InverseKinematicsTest(),\r
+ new IsoCamTest(),\r
+ new IsometricTileTest(),\r
+ new MatrixJNITest(),\r
+ new MeshShaderTest(),\r
+ new MultitouchTest(),\r
+ new MusicTest(),\r
+ new ParallaxTest(),\r
+ new ParticleEmitterTest(),\r
+ new PixelsPerInchTest(),\r
+// new PixmapBlendingTest(), // no idea why this doesn't work\r
+ new RotationTest(),\r
+ new ShaderMultitextureTest(),\r
+ new ShapeRendererTest(),\r
+ new SimpleAnimationTest(),\r
+ new SimpleDecalTest(),\r
+ new SortedSpriteTest(),\r
+ new SpriteBatchShaderTest(),\r
+ new SpriteCacheOffsetTest(),\r
+ new SpriteCacheTest(),\r
+ new TextureAtlasTest(),\r
+ new VertexBufferObjectShaderTest(),\r
+ new YDownTest()\r
+ };\r
+ \r
@Override\r
public GwtApplicationConfiguration getConfig () {\r
return new GwtApplicationConfiguration(640, 640);\r
\r
@Override\r
public ApplicationListener getApplicationListener () {\r
- return new GwtBinaryTest();\r
+ return new AssetManagerTest();\r
}\r
}\r
b:data/walk1.md5anim
i:data/walkanim.png
i:data/wheel.png
-b:data/zfat.md5mesh
\ No newline at end of file
+b:data/zfat.md5mesh
\r
import com.badlogic.gdx.backends.lwjgl.LwjglApplication;\r
import com.badlogic.gdx.backends.lwjgl.LwjglApplicationConfiguration;\r
+import com.badlogic.gdx.tests.AssetManagerTest;\r
+import com.badlogic.gdx.tests.AtlasIssueTest;\r
+import com.badlogic.gdx.tests.BitmapFontAlignmentTest;\r
+import com.badlogic.gdx.tests.CustomShaderSpriteBatchTest;\r
+import com.badlogic.gdx.tests.DecalTest;\r
import com.badlogic.gdx.tests.MeshShaderTest;\r
+import com.badlogic.gdx.tests.ParticleEmitterTest;\r
+import com.badlogic.gdx.tests.PixelsPerInchTest;\r
+import com.badlogic.gdx.tests.PixmapBlendingTest;\r
+import com.badlogic.gdx.tests.ShaderMultitextureTest;\r
+import com.badlogic.gdx.tests.SpriteBatchShaderTest;\r
+import com.badlogic.gdx.tests.SpriteCacheOffsetTest;\r
+import com.badlogic.gdx.tests.VertexBufferObjectShaderTest;\r
import com.badlogic.gdx.tests.gwt.GwtBinaryTest;\r
import com.badlogic.gdx.tests.utils.GdxTest;\r
import com.badlogic.gdx.utils.SharedLibraryLoader;\r
new SharedLibraryLoader("../../extensions/gdx-image/libs/gdx-image-natives.jar").load("gdx-image");\r
new SharedLibraryLoader("../../extensions/gdx-freetype/libs/gdx-freetype-natives.jar").load("gdx-freetype");\r
\r
- GdxTest test = new GwtBinaryTest();\r
+ GdxTest test = new AssetManagerTest();\r
LwjglApplicationConfiguration config = new LwjglApplicationConfiguration();\r
config.width = 800;\r
config.height = 480;\r
<?xml version="1.0" encoding="UTF-8"?>\r
<!DOCTYPE module PUBLIC "-//Google Inc.//DTD Google Web Toolkit trunk//EN" "http://google-web-toolkit.googlecode.com/svn/trunk/distro-source/core/src/gwt-module.dtd">\r
<module>\r
- <source path="tests"/>\r
+ <source path="tests">\r
+ <exclude name="**/box2d/**"/>\r
+ <exclude name="**/AudioDeviceTest.java"/>\r
+ <exclude name="**/AudioRecorderTest.java"/>\r
+ <exclude name="**/ActionTest.java"/>\r
+ <exclude name="**/ActionSequenceTest.java"/>\r
+ <exclude name="**/Box2DCharacterControllerTest.java"/>\r
+ <exclude name="**/Box2DInitialOverlapTest.java"/>\r
+ <exclude name="**/Box2DTest.java"/>\r
+ <exclude name="**/Box2DTestCollection.java"/>\r
+ <exclude name="**/BufferUtilsTest.java"/>\r
+ <exclude name="**/ComplexActionTest.java"/>\r
+ <exclude name="**/ETC1Test.java"/>\r
+ <exclude name="**/FFTTest.java"/>\r
+ <exclude name="**/FlickScrollPaneTest.java"/>\r
+ <exclude name="**/FramebufferToTextureTest.java"/>\r
+ <exclude name="**/FreeTypeTest.java"/>\r
+ <exclude name="**/Gdx2DTest.java"/>\r
+ <exclude name="**/GroupCullingTest.java"/>\r
+ <exclude name="**/GroupFadeTest.java"/>\r
+ <exclude name="**/ImageScaleTest.java"/>\r
+ <exclude name="**/ImageTest.java"/>\r
+ <exclude name="**/InterpolationTest.java"/>\r
+ <exclude name="**/JpegTest.java"/>\r
+ <exclude name="**/KinematicBodyTest.java"/>\r
+ <exclude name="**/LabelTest.java"/>\r
+ <exclude name="**/LifeCycleTest.java"/>\r
+ <exclude name="**/MipMapTest.java"/>\r
+ <exclude name="**/Mpg123Test.java"/>\r
+ <exclude name="**/ProjectiveTextureTest.java"/>\r
+ <exclude name="**/RemoteTest.java"/>\r
+ <exclude name="**/ScreenCaptureTest.java"/>\r
+ <exclude name="**/ScrollPaneTest.java"/>\r
+ <exclude name="**/ShadowMappingTest.java"/>\r
+ <exclude name="**/SimpleStageCullingTest.java"/>\r
+ <exclude name="**/SoundTest.java"/>\r
+ <exclude name="**/SoundTouchTest.java"/>\r
+ <exclude name="**/StagePerformanceTest.java"/>\r
+ <exclude name="**/StageTest.java"/>\r
+ <exclude name="**/StbTrueTypeTest.java"/>\r
+ <exclude name="**/TextButtonTestGL2.java"/>\r
+ <exclude name="**/TextureDownloadTest.java"/>\r
+ <exclude name="**/TTFFactoryTest.java"/>\r
+ <exclude name="**/TableTest.java"/>\r
+ <exclude name="**/TextButtonTest.java"/>\r
+ <exclude name="**/TileTest.java"/>\r
+ <exclude name="**/TiledMapTest.java"/>\r
+ <exclude name="**/UITest.java"/>\r
+ <exclude name="**/VorbisTest.java"/>\r
+ <exclude name="**/WavTest.java"/>\r
+ <exclude name="**/AssetsFileGenerator.java"/>\r
+ <exclude name="**/GdxTests.java"/>\r
+ </source>\r
</module>
\ No newline at end of file
import com.badlogic.gdx.assets.AssetErrorListener;\r
import com.badlogic.gdx.assets.AssetManager;\r
import com.badlogic.gdx.assets.loaders.TextureLoader;\r
-import com.badlogic.gdx.assets.loaders.TileMapRendererLoader;\r
import com.badlogic.gdx.assets.loaders.resolvers.InternalFileHandleResolver;\r
import com.badlogic.gdx.assets.loaders.resolvers.ResolutionFileResolver;\r
import com.badlogic.gdx.assets.loaders.resolvers.ResolutionFileResolver.Resolution;\r
import com.badlogic.gdx.graphics.g2d.BitmapFont;\r
import com.badlogic.gdx.graphics.g2d.SpriteBatch;\r
import com.badlogic.gdx.graphics.g2d.TextureAtlas;\r
-import com.badlogic.gdx.graphics.g2d.tiled.TileAtlas;\r
-import com.badlogic.gdx.graphics.g2d.tiled.TileMapRenderer;\r
-import com.badlogic.gdx.graphics.g2d.tiled.TiledLoader;\r
-import com.badlogic.gdx.graphics.g2d.tiled.TiledMap;\r
import com.badlogic.gdx.tests.utils.GdxTest;\r
import com.badlogic.gdx.utils.BufferUtils;\r
+import com.badlogic.gdx.utils.TimeUtils;\r
\r
public class AssetManagerTest extends GdxTest implements AssetErrorListener {\r
@Override\r
\r
boolean diagnosed = false;\r
private long start;\r
- private TileMapRenderer renderer;\r
- private TileAtlas atlas;\r
- private TiledMap map;\r
- private Texture tex3;\r
+// private TileMapRenderer renderer;\r
+// private TileAtlas atlas;\r
+// private TiledMap map;\r
+// private Texture tex3;\r
private BitmapFont font2;\r
private TextureAtlas tex2;\r
private Texture tex1;\r
\r
private void load() {\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
tex1 = new Texture("data/animation.png");\r
tex2 = new TextureAtlas(Gdx.files.internal("data/pack"));\r
font2 = new BitmapFont(Gdx.files.internal("data/verdana39.fnt"), false);\r
- tex3 = new Texture("data/test.etc1");\r
- map = TiledLoader.createMap(Gdx.files.internal("data/tiledmap/tilemap csv.tmx"));\r
- atlas = new TileAtlas(map, Gdx.files.internal("data/tiledmap/"));\r
- renderer = new TileMapRenderer(map, atlas, 8, 8);\r
- System.out.println("plain took: " + (System.nanoTime() - start) / 1000000000.0f);\r
+// tex3 = new Texture("data/test.etc1");\r
+// map = TiledLoader.createMap(Gdx.files.internal("data/tiledmap/tilemap csv.tmx"));\r
+// atlas = new TileAtlas(map, Gdx.files.internal("data/tiledmap/"));\r
+// renderer = new TileMapRenderer(map, atlas, 8, 8);\r
+ System.out.println("plain took: " + (TimeUtils.nanoTime() - start) / 1000000000.0f);\r
\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
manager.load("data/animation.png", Texture.class);\r
manager.load("data/pack1.png", Texture.class);\r
manager.load("data/pack", TextureAtlas.class);\r
manager.load("data/verdana39.png", Texture.class);\r
manager.load("data/verdana39.fnt", BitmapFont.class);\r
- manager.load("data/test.etc1", Texture.class);\r
- manager.load("data/tiledmap/tilemap csv.tmx", TileMapRenderer.class, new TileMapRendererLoader.TileMapParameter("data/tiledmap/", 8, 8));\r
+// manager.load("data/test.etc1", Texture.class);\r
+// manager.load("data/tiledmap/tilemap csv.tmx", TileMapRenderer.class, new TileMapRendererLoader.TileMapParameter("data/tiledmap/", 8, 8));\r
}\r
\r
private void unload() {\r
tex1.dispose();\r
tex2.dispose();\r
font2.dispose();\r
- tex3.dispose();\r
- atlas.dispose();\r
- renderer.dispose();\r
+// tex3.dispose();\r
+// atlas.dispose();\r
+// renderer.dispose();\r
\r
manager.unload("data/animation.png");\r
manager.unload("data/pack1.png");\r
manager.unload("data/pack");\r
manager.unload("data/verdana39.png");\r
manager.unload("data/verdana39.fnt");\r
- manager.unload("data/test.etc1");\r
- manager.unload("data/tiledmap/tilemap csv.tmx");\r
+// manager.unload("data/test.etc1");\r
+// manager.unload("data/tiledmap/tilemap csv.tmx");\r
}\r
\r
private void invalidateTexture(Texture texture) {\r
Gdx.gl.glClear(GL10.GL_COLOR_BUFFER_BIT);\r
boolean result = manager.update();\r
if (result & !diagnosed) {\r
-// Gdx.app.log("AssetManagerTest", "\n" + manager.getDiagnostics() + "\n" + Texture.getManagedStatus());\r
diagnosed = true;\r
- System.out.println("took: " + (System.nanoTime() - start) / 1000000000.0f);\r
+ System.out.println("took: " + (TimeUtils.nanoTime() - start) / 1000000000.0f);\r
unload();\r
load();\r
diagnosed = false;\r
frame++;\r
\r
batch.begin();\r
- if (manager.isLoaded("data/test.etc1")) batch.draw(manager.get("data/test.etc1", Texture.class), 0, 0);\r
if (manager.isLoaded("data/animation.png")) batch.draw(manager.get("data/animation.png", Texture.class), 100, 100);\r
if (manager.isLoaded("data/verdana39.png")) batch.draw(manager.get("data/verdana39.png", Texture.class), 300, 100);\r
if (manager.isLoaded("data/pack")) batch.draw(manager.get("data/pack", TextureAtlas.class).findRegion("particle-star"), 164, 100);\r
if (manager.isLoaded("data/verdana39.fnt")) manager.get("data/verdana39.fnt", BitmapFont.class).draw(batch, "This is a test", 100, 200);\r
- if (manager.isLoaded("data/tiledmap/tilemap csv.tmx")) manager.get("data/tiledmap/tilemap csv.tmx", TileMapRenderer.class).render();\r
+// if (manager.isLoaded("data/test.etc1")) batch.draw(manager.get("data/test.etc1", Texture.class), 0, 0);\r
+// if (manager.isLoaded("data/tiledmap/tilemap csv.tmx")) manager.get("data/tiledmap/tilemap csv.tmx", TileMapRenderer.class).render();\r
font.draw(batch, "loaded: " + manager.getProgress() + ", reloads: " + reloads, 0, 30);\r
batch.end();\r
\r
\r
@Override\r
public void render () {\r
- GL10 gl = Gdx.graphics.getGL10();\r
- gl.glClear(GL10.GL_COLOR_BUFFER_BIT);\r
+ Gdx.gl.glClear(GL10.GL_COLOR_BUFFER_BIT);\r
spriteBatch.begin();\r
logoSprite.draw(spriteBatch);\r
switch (renderMode) {\r
public void render () {\r
red.a = (red.a + Gdx.graphics.getDeltaTime() * 0.1f) % 1;\r
\r
- GL10 gl = Gdx.graphics.getGL10();\r
- gl.glClear(GL10.GL_COLOR_BUFFER_BIT);\r
+ Gdx.gl.glClear(GL10.GL_COLOR_BUFFER_BIT);\r
spriteBatch.begin();\r
logoSprite.draw(spriteBatch);\r
switch (renderMode) {\r
import com.badlogic.gdx.graphics.g2d.SpriteBatch;\r
import com.badlogic.gdx.graphics.g2d.TextureAtlas;\r
import com.badlogic.gdx.graphics.glutils.ImmediateModeRenderer10;\r
+import com.badlogic.gdx.graphics.glutils.ShapeRenderer;\r
+import com.badlogic.gdx.graphics.glutils.ShapeRenderer.ShapeType;\r
import com.badlogic.gdx.tests.utils.GdxTest;\r
\r
public class BitmapFontTest extends GdxTest {\r
private SpriteBatch spriteBatch;\r
private BitmapFont font;\r
- ImmediateModeRenderer10 renderer;\r
-\r
+ private ShapeRenderer renderer;\r
+ \r
@Override\r
public void create () {\r
spriteBatch = new SpriteBatch();\r
-\r
TextureAtlas textureAtlas = new TextureAtlas("data/pack");\r
font = new BitmapFont(Gdx.files.internal("data/verdana39.fnt"), textureAtlas.findRegion("verdana39"), false);\r
-\r
- renderer = new ImmediateModeRenderer10();\r
+ renderer = new ShapeRenderer();\r
+ renderer.setProjectionMatrix(spriteBatch.getProjectionMatrix());\r
}\r
\r
@Override\r
\r
int viewHeight = Gdx.graphics.getHeight();\r
\r
- GL10 gl = Gdx.graphics.getGL10();\r
- gl.glClearColor(1, 1, 1, 1);\r
- gl.glClear(GL10.GL_COLOR_BUFFER_BIT);\r
+ Gdx.gl.glClearColor(1, 1, 1, 1);\r
+ Gdx.gl.glClear(GL10.GL_COLOR_BUFFER_BIT);\r
spriteBatch.begin();\r
\r
String text = "Sphinx of black quartz, judge my vow.";\r
\r
spriteBatch.end();\r
\r
- drawRect(x, viewHeight - y, x + alignmentWidth, 300);\r
- }\r
-\r
- public void drawRect (float x1, float y1, float x2, float y2) {\r
- renderer.begin(GL10.GL_LINE_STRIP);\r
- renderer.vertex(x1, y1, 0);\r
- renderer.vertex(x1, y2, 0);\r
- renderer.vertex(x2, y2, 0);\r
- renderer.vertex(x2, y1, 0);\r
- renderer.vertex(x1, y1, 0);\r
+ renderer.begin(ShapeType.Rectangle);\r
+ renderer.rect(x, viewHeight - y, x + alignmentWidth, 300);\r
renderer.end();\r
}\r
\r
import com.badlogic.gdx.tests.utils.GdxTest;\r
import com.badlogic.gdx.utils.BufferUtils;\r
import com.badlogic.gdx.utils.GdxRuntimeException;\r
+import com.badlogic.gdx.utils.TimeUtils;\r
\r
public class BufferUtilsTest extends GdxTest {\r
static final int NUM_MB = 5;\r
final int NUM_MB = 5;\r
\r
// relative put\r
- long start = System.nanoTime();\r
+ long start = TimeUtils.nanoTime();\r
for (int j = 0; j < NUM_MB; j++) {\r
bb.clear();\r
for (int i = 0; i < len; i++)\r
bb.put(bytes[i]);\r
}\r
- Gdx.app.log("BufferUtilsTest", "ByteBuffer relative put: " + (System.nanoTime() - start) / 1000000000.0f);\r
+ Gdx.app.log("BufferUtilsTest", "ByteBuffer relative put: " + (TimeUtils.nanoTime() - start) / 1000000000.0f);\r
\r
// absolute put\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
for (int j = 0; j < NUM_MB; j++) {\r
bb.clear();\r
for (int i = 0; i < len; i++)\r
bb.put(i, bytes[i]);\r
}\r
- Gdx.app.log("BufferUtilsTest", "ByteBuffer absolute put: " + (System.nanoTime() - start) / 1000000000.0f);\r
+ Gdx.app.log("BufferUtilsTest", "ByteBuffer absolute put: " + (TimeUtils.nanoTime() - start) / 1000000000.0f);\r
\r
// bulk put\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
for (int j = 0; j < NUM_MB; j++) {\r
bb.clear();\r
bb.put(bytes);\r
}\r
- Gdx.app.log("BufferUtilsTest", "ByteBuffer bulk put: " + (System.nanoTime() - start) / 1000000000.0f);\r
+ Gdx.app.log("BufferUtilsTest", "ByteBuffer bulk put: " + (TimeUtils.nanoTime() - start) / 1000000000.0f);\r
\r
// JNI put\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
for (int j = 0; j < NUM_MB; j++) {\r
bb.clear();\r
BufferUtils.copy(bytes, 0, bb, len);\r
}\r
- Gdx.app.log("BufferUtilsTest", "ByteBuffer native bulk put: " + (System.nanoTime() - start) / 1000000000.0f);\r
+ Gdx.app.log("BufferUtilsTest", "ByteBuffer native bulk put: " + (TimeUtils.nanoTime() - start) / 1000000000.0f);\r
}\r
\r
private void benchShort () {\r
int len = shorts.length;\r
\r
// relative put\r
- long start = System.nanoTime();\r
+ long start = TimeUtils.nanoTime();\r
for (int j = 0; j < NUM_MB; j++) {\r
sb.clear();\r
for (int i = 0; i < len; i++)\r
sb.put(shorts[i]);\r
}\r
- Gdx.app.log("BufferUtilsTest", "ShortBuffer relative put: " + (System.nanoTime() - start) / 1000000000.0f);\r
+ Gdx.app.log("BufferUtilsTest", "ShortBuffer relative put: " + (TimeUtils.nanoTime() - start) / 1000000000.0f);\r
\r
// absolute put\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
for (int j = 0; j < NUM_MB; j++) {\r
sb.clear();\r
for (int i = 0; i < len; i++)\r
sb.put(i, shorts[i]);\r
}\r
- Gdx.app.log("BufferUtilsTest", "ShortBuffer absolute put: " + (System.nanoTime() - start) / 1000000000.0f);\r
+ Gdx.app.log("BufferUtilsTest", "ShortBuffer absolute put: " + (TimeUtils.nanoTime() - start) / 1000000000.0f);\r
\r
// bulk put\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
for (int j = 0; j < NUM_MB; j++) {\r
sb.clear();\r
sb.put(shorts);\r
}\r
- Gdx.app.log("BufferUtilsTest", "ShortBuffer bulk put: " + (System.nanoTime() - start) / 1000000000.0f);\r
+ Gdx.app.log("BufferUtilsTest", "ShortBuffer bulk put: " + (TimeUtils.nanoTime() - start) / 1000000000.0f);\r
\r
// JNI put\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
for (int j = 0; j < NUM_MB; j++) {\r
sb.clear();\r
BufferUtils.copy(shorts, 0, sb, len);\r
}\r
- Gdx.app.log("BufferUtilsTest", "ShortBuffer native bulk put: " + (System.nanoTime() - start) / 1000000000.0f);\r
+ Gdx.app.log("BufferUtilsTest", "ShortBuffer native bulk put: " + (TimeUtils.nanoTime() - start) / 1000000000.0f);\r
}\r
\r
private void benchInt () {\r
int len = ints.length;\r
\r
// relative put\r
- long start = System.nanoTime();\r
+ long start = TimeUtils.nanoTime();\r
for (int j = 0; j < NUM_MB; j++) {\r
ib.clear();\r
for (int i = 0; i < len; i++)\r
ib.put(ints[i]);\r
}\r
- Gdx.app.log("BufferUtilsTest", "IntBuffer relative put: " + (System.nanoTime() - start) / 1000000000.0f);\r
+ Gdx.app.log("BufferUtilsTest", "IntBuffer relative put: " + (TimeUtils.nanoTime() - start) / 1000000000.0f);\r
\r
// absolute put\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
for (int j = 0; j < NUM_MB; j++) {\r
ib.clear();\r
for (int i = 0; i < len; i++)\r
ib.put(i, ints[i]);\r
}\r
- Gdx.app.log("BufferUtilsTest", "IntBuffer absolute put: " + (System.nanoTime() - start) / 1000000000.0f);\r
+ Gdx.app.log("BufferUtilsTest", "IntBuffer absolute put: " + (TimeUtils.nanoTime() - start) / 1000000000.0f);\r
\r
// bulk put\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
for (int j = 0; j < NUM_MB; j++) {\r
ib.clear();\r
ib.put(ints);\r
}\r
- Gdx.app.log("BufferUtilsTest", "IntBuffer bulk put: " + (System.nanoTime() - start) / 1000000000.0f);\r
+ Gdx.app.log("BufferUtilsTest", "IntBuffer bulk put: " + (TimeUtils.nanoTime() - start) / 1000000000.0f);\r
\r
// JNI put\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
for (int j = 0; j < NUM_MB; j++) {\r
ib.clear();\r
BufferUtils.copy(ints, 0, ib, len);\r
}\r
- Gdx.app.log("BufferUtilsTest", "IntBuffer native bulk put: " + (System.nanoTime() - start) / 1000000000.0f);\r
+ Gdx.app.log("BufferUtilsTest", "IntBuffer native bulk put: " + (TimeUtils.nanoTime() - start) / 1000000000.0f);\r
}\r
\r
private void benchLong () {\r
int len = longs.length;\r
\r
// relative put\r
- long start = System.nanoTime();\r
+ long start = TimeUtils.nanoTime();\r
for (int j = 0; j < NUM_MB; j++) {\r
lb.clear();\r
for (int i = 0; i < len; i++)\r
lb.put(longs[i]);\r
}\r
- Gdx.app.log("BufferUtilsTest", "LongBuffer relative put: " + (System.nanoTime() - start) / 1000000000.0f);\r
+ Gdx.app.log("BufferUtilsTest", "LongBuffer relative put: " + (TimeUtils.nanoTime() - start) / 1000000000.0f);\r
\r
// absolute put\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
for (int j = 0; j < NUM_MB; j++) {\r
lb.clear();\r
for (int i = 0; i < len; i++)\r
lb.put(i, longs[i]);\r
}\r
- Gdx.app.log("BufferUtilsTest", "LongBuffer absolute put: " + (System.nanoTime() - start) / 1000000000.0f);\r
+ Gdx.app.log("BufferUtilsTest", "LongBuffer absolute put: " + (TimeUtils.nanoTime() - start) / 1000000000.0f);\r
\r
// bulk put\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
for (int j = 0; j < NUM_MB; j++) {\r
lb.clear();\r
lb.put(longs);\r
}\r
- Gdx.app.log("BufferUtilsTest", "LongBuffer bulk put: " + (System.nanoTime() - start) / 1000000000.0f);\r
+ Gdx.app.log("BufferUtilsTest", "LongBuffer bulk put: " + (TimeUtils.nanoTime() - start) / 1000000000.0f);\r
\r
// JNI put\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
for (int j = 0; j < NUM_MB; j++) {\r
lb.clear();\r
BufferUtils.copy(longs, 0, lb, len);\r
}\r
- Gdx.app.log("BufferUtilsTest", "LongBuffer native bulk put: " + (System.nanoTime() - start) / 1000000000.0f);\r
+ Gdx.app.log("BufferUtilsTest", "LongBuffer native bulk put: " + (TimeUtils.nanoTime() - start) / 1000000000.0f);\r
}\r
\r
private void benchFloat () {\r
int len = floats.length;\r
\r
// relative put\r
- long start = System.nanoTime();\r
+ long start = TimeUtils.nanoTime();\r
for (int j = 0; j < NUM_MB; j++) {\r
fb.clear();\r
for (int i = 0; i < len; i++)\r
fb.put(floats[i]);\r
}\r
- Gdx.app.log("BufferUtilsTest", "FloatBuffer relative put: " + (System.nanoTime() - start) / 1000000000.0f);\r
+ Gdx.app.log("BufferUtilsTest", "FloatBuffer relative put: " + (TimeUtils.nanoTime() - start) / 1000000000.0f);\r
\r
// absolute put\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
for (int j = 0; j < NUM_MB; j++) {\r
fb.clear();\r
for (int i = 0; i < len; i++)\r
fb.put(i, floats[i]);\r
}\r
- Gdx.app.log("BufferUtilsTest", "FloatBuffer absolute put: " + (System.nanoTime() - start) / 1000000000.0f);\r
+ Gdx.app.log("BufferUtilsTest", "FloatBuffer absolute put: " + (TimeUtils.nanoTime() - start) / 1000000000.0f);\r
\r
// bulk put\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
for (int j = 0; j < NUM_MB; j++) {\r
fb.clear();\r
fb.put(floats);\r
}\r
- Gdx.app.log("BufferUtilsTest", "FloatBuffer bulk put: " + (System.nanoTime() - start) / 1000000000.0f);\r
+ Gdx.app.log("BufferUtilsTest", "FloatBuffer bulk put: " + (TimeUtils.nanoTime() - start) / 1000000000.0f);\r
\r
// JNI put\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
for (int j = 0; j < NUM_MB; j++) {\r
fb.clear();\r
BufferUtils.copy(floats, 0, fb, len);\r
}\r
- Gdx.app.log("BufferUtilsTest", "FloatBuffer native bulk put: " + (System.nanoTime() - start) / 1000000000.0f);\r
+ Gdx.app.log("BufferUtilsTest", "FloatBuffer native bulk put: " + (TimeUtils.nanoTime() - start) / 1000000000.0f);\r
}\r
\r
private void benchDouble () {\r
int len = doubles.length;\r
\r
// relative put\r
- long start = System.nanoTime();\r
+ long start = TimeUtils.nanoTime();\r
for (int j = 0; j < NUM_MB; j++) {\r
db.clear();\r
for (int i = 0; i < len; i++)\r
db.put(doubles[i]);\r
}\r
- Gdx.app.log("BufferUtilsTest", "DoubleBuffer relative put: " + (System.nanoTime() - start) / 1000000000.0f);\r
+ Gdx.app.log("BufferUtilsTest", "DoubleBuffer relative put: " + (TimeUtils.nanoTime() - start) / 1000000000.0f);\r
\r
// absolute put\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
for (int j = 0; j < NUM_MB; j++) {\r
db.clear();\r
for (int i = 0; i < len; i++)\r
db.put(i, doubles[i]);\r
}\r
- Gdx.app.log("BufferUtilsTest", "DoubleBuffer absolute put: " + (System.nanoTime() - start) / 1000000000.0f);\r
+ Gdx.app.log("BufferUtilsTest", "DoubleBuffer absolute put: " + (TimeUtils.nanoTime() - start) / 1000000000.0f);\r
\r
// bulk put\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
for (int j = 0; j < NUM_MB; j++) {\r
db.clear();\r
db.put(doubles);\r
}\r
- Gdx.app.log("BufferUtilsTest", "DoubleBuffer bulk put: " + (System.nanoTime() - start) / 1000000000.0f);\r
+ Gdx.app.log("BufferUtilsTest", "DoubleBuffer bulk put: " + (TimeUtils.nanoTime() - start) / 1000000000.0f);\r
\r
// JNI put\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
for (int j = 0; j < NUM_MB; j++) {\r
db.clear();\r
BufferUtils.copy(doubles, 0, db, len);\r
}\r
- Gdx.app.log("BufferUtilsTest", "DoubleBuffer bulk put: " + (System.nanoTime() - start) / 1000000000.0f);\r
+ Gdx.app.log("BufferUtilsTest", "DoubleBuffer bulk put: " + (TimeUtils.nanoTime() - start) / 1000000000.0f);\r
}\r
\r
private void checkInt (long val1, long val2) {\r
import com.badlogic.gdx.graphics.OrthographicCamera;\r
import com.badlogic.gdx.graphics.Texture;\r
import com.badlogic.gdx.graphics.g2d.TextureRegion;\r
+import com.badlogic.gdx.graphics.g3d.decals.CameraGroupStrategy;\r
import com.badlogic.gdx.graphics.g3d.decals.Decal;\r
import com.badlogic.gdx.graphics.g3d.decals.DecalBatch;\r
import com.badlogic.gdx.graphics.g3d.decals.GroupStrategy;\r
public static final int TARGET_FPS = 40;\r
public static final int INITIAL_RENDERED = 100;\r
private boolean willItBlend_that_is_the_question = true;\r
- private GroupStrategy strategy = new SimpleOrthoGroupStrategy();\r
- // private GroupStrategy strategy = new DefaultGroupStrategy();\r
Texture egg;\r
Texture wheel;\r
LinkedList<Decal> toRender = new LinkedList<Decal>();\r
@Override\r
public void create () {\r
Gdx.gl.glEnable(GL10.GL_DEPTH_TEST);\r
- Gdx.gl10.glDepthFunc(GL10.GL_LESS);\r
+ Gdx.gl.glDepthFunc(GL10.GL_LESS);\r
\r
egg = new Texture(Gdx.files.internal("data/egg.png"));\r
egg.setFilter(Texture.TextureFilter.Linear, Texture.TextureFilter.Linear);\r
h = Gdx.graphics.getHeight() / 0.8f;\r
for (int i = 0; i < INITIAL_RENDERED; i++) {\r
toRender.add(makeDecal());\r
- }\r
- batch = new DecalBatch(strategy);\r
+ } \r
+ cam = new OrthographicCamera(Gdx.graphics.getWidth(), Gdx.graphics.getHeight());\r
+ cam.near = 0.1f;\r
+ cam.far = 10f;\r
+ cam.position.set(0, 0, 0.1f);\r
+ cam.direction.set(0, 0, -1f);\r
+ batch = new DecalBatch(new CameraGroupStrategy(cam));\r
\r
Gdx.gl.glClearColor(1, 1, 0, 1);\r
}\r
cam.far = 10f;\r
cam.position.set(0, 0, 0.1f);\r
cam.direction.set(0, 0, -1f);\r
- cam.update();\r
- cam.apply(Gdx.gl10);\r
}\r
\r
private Decal makeDecal () {\r
\r
import com.badlogic.gdx.Gdx;\r
import com.badlogic.gdx.tests.utils.GdxTest;\r
+import com.badlogic.gdx.utils.TimeUtils;\r
\r
public class DeltaTimeTest extends GdxTest {\r
\r
\r
@Override\r
public void create () {\r
- lastFrameTime = System.nanoTime();\r
+ lastFrameTime = TimeUtils.nanoTime();\r
}\r
\r
@Override\r
public void render () {\r
- long frameTime = System.nanoTime();\r
+ long frameTime = TimeUtils.nanoTime();\r
float deltaTime = (frameTime - lastFrameTime) / 1000000000.0f;\r
lastFrameTime = frameTime;\r
\r
import com.badlogic.gdx.graphics.VertexAttribute;\r
import com.badlogic.gdx.graphics.VertexAttributes;\r
import com.badlogic.gdx.tests.utils.GdxTest;\r
+import com.badlogic.gdx.utils.TimeUtils;\r
\r
public class FillrateTest extends GdxTest implements InputProcessor {\r
Texture texture;\r
Mesh mesh;\r
int numFills = 1;\r
- long lastOut = System.nanoTime();\r
+ long lastOut = TimeUtils.nanoTime();\r
\r
int mode = 0;\r
float mean = 0;\r
\r
if (Gdx.graphics.getDeltaTime() < 1 / 60f) numFills++;\r
\r
- if (System.nanoTime() - lastOut >= 1000000000) {\r
+ if (TimeUtils.nanoTime() - lastOut >= 1000000000) {\r
Gdx.app.log("FillrateTest", "fills: " + mean / frames + ", fps: " + frames + ", mode" + mode);\r
mean = 0;\r
frames = 0;\r
- lastOut = System.nanoTime();\r
+ lastOut = TimeUtils.nanoTime();\r
if (Gdx.graphics.getFramesPerSecond() < 60) numFills--;\r
}\r
}\r
import com.badlogic.gdx.graphics.g2d.BitmapFont.HAlignment;\r
import com.badlogic.gdx.graphics.g2d.BitmapFontCache;\r
import com.badlogic.gdx.graphics.g2d.SpriteBatch;\r
+import com.badlogic.gdx.graphics.g2d.TextureAtlas;\r
import com.badlogic.gdx.tests.utils.GdxTest;\r
\r
public class IntegerBitmapFontTest extends GdxTest {\r
SpriteBatch batch;\r
\r
public void create () {\r
- font = new BitmapFont();\r
+ TextureAtlas textureAtlas = new TextureAtlas("data/pack");\r
+ font = new BitmapFont(Gdx.files.internal("data/verdana39.fnt"), textureAtlas.findRegion("verdana39"), false);\r
singleLineCache = new BitmapFontCache(font, true);\r
multiLineCache = new BitmapFontCache(font, true);\r
singleLineCacheNonInteger = new BitmapFontCache(font, false);\r
import com.badlogic.gdx.graphics.GL10;\r
import com.badlogic.gdx.graphics.OrthographicCamera;\r
import com.badlogic.gdx.graphics.glutils.ImmediateModeRenderer10;\r
+import com.badlogic.gdx.graphics.glutils.ShapeRenderer;\r
+import com.badlogic.gdx.graphics.glutils.ShapeRenderer.ShapeType;\r
import com.badlogic.gdx.math.Vector2;\r
import com.badlogic.gdx.math.Vector3;\r
import com.badlogic.gdx.tests.utils.GdxTest;\r
\r
static final float GRAVITY = 0;\r
OrthographicCamera camera;\r
- ImmediateModeRenderer10 renderer;\r
+ ShapeRenderer renderer;\r
Bone[] bones;\r
Vector3 globalCoords = new Vector3();\r
Vector3 endPoint = new Vector3();\r
public void create () {\r
float aspect = Gdx.graphics.getWidth() / (float)Gdx.graphics.getHeight();\r
camera = new OrthographicCamera(15 * aspect, 15);\r
- renderer = new ImmediateModeRenderer10();\r
+ camera.update();\r
+ renderer = new ShapeRenderer();\r
+ renderer.setProjectionMatrix(camera.combined);\r
\r
bones = new Bone[] {new Bone("bone0", 0, 0, 0), new Bone("bone1", 0, 2, 2), new Bone("bone2", 0, 4, 2),\r
new Bone("bone3", 0, 6, 2), new Bone("end", 0, 8, 2)};\r
Gdx.gl.glClear(GL10.GL_COLOR_BUFFER_BIT);\r
\r
camera.update();\r
- camera.apply(Gdx.gl10);\r
+ renderer.setProjectionMatrix(camera.combined);\r
\r
if (Gdx.input.isTouched()) camera.unproject(globalCoords.set(Gdx.input.getX(), Gdx.input.getY(), 0));\r
solveFakeIK(globalCoords);\r
}\r
\r
private void renderBones () {\r
- renderer.begin(GL10.GL_LINES);\r
+ renderer.begin(ShapeType.Line);\r
+ renderer.setColor(0, 1, 0, 1);\r
for (int i = 0; i < bones.length - 1; i++) {\r
- renderer.color(0, 1, 0, 1);\r
- renderer.vertex(bones[i].position);\r
- renderer.color(0, 1, 0, 1);\r
- renderer.vertex(bones[i + 1].position);\r
+ renderer.line(bones[i].position.x, bones[i].position.y, bones[i + 1].position.x, bones[i + 1].position.y);\r
}\r
renderer.end();\r
\r
- Gdx.gl10.glPointSize(5);\r
-\r
- renderer.begin(GL10.GL_POINTS);\r
+ renderer.begin(ShapeType.Point);\r
+ renderer.setColor(1, 0, 0, 1);\r
for (int i = 0; i < bones.length; i++) {\r
- renderer.color(1, 0, 0, 1);\r
- renderer.vertex(bones[i].position);\r
+ renderer.point(bones[i].position.x, bones[i].position.y, 0);\r
}\r
renderer.end();\r
- Gdx.gl10.glPointSize(1);\r
}\r
\r
public void solveFakeIK (Vector3 target) {\r
import com.badlogic.gdx.graphics.Texture;\r
import com.badlogic.gdx.graphics.g2d.SpriteCache;\r
import com.badlogic.gdx.graphics.glutils.ImmediateModeRenderer10;\r
+import com.badlogic.gdx.graphics.glutils.ShapeRenderer;\r
+import com.badlogic.gdx.graphics.glutils.ShapeRenderer.ShapeType;\r
import com.badlogic.gdx.tests.utils.GdxTest;\r
import com.badlogic.gdx.tests.utils.OrthoCamController;\r
+import com.badlogic.gdx.utils.TimeUtils;\r
\r
public class IsometricTileTest extends GdxTest {\r
static final int LAYERS = 1;\r
int[] layers = new int[LAYERS];\r
OrthographicCamera cam;\r
OrthoCamController camController;\r
- ImmediateModeRenderer10 renderer;\r
- long startTime = System.nanoTime();\r
+ ShapeRenderer renderer;\r
+ long startTime = TimeUtils.nanoTime();\r
\r
@Override\r
public void create () {\r
camController = new OrthoCamController(cam);\r
Gdx.input.setInputProcessor(camController);\r
\r
- renderer = new ImmediateModeRenderer10();\r
+ renderer = new ShapeRenderer();\r
texture = new Texture(Gdx.files.internal("data/isotile.png"));\r
\r
Random rand = new Random();\r
\r
@Override\r
public void render () {\r
- GL10 gl = Gdx.gl10;\r
- gl.glClearColor(0.7f, 0.7f, 0.7f, 1);\r
- gl.glClear(GL10.GL_COLOR_BUFFER_BIT);\r
+ Gdx.gl.glClearColor(0.7f, 0.7f, 0.7f, 1);\r
+ Gdx.gl.glClear(GL10.GL_COLOR_BUFFER_BIT);\r
cam.update();\r
\r
- gl.glEnable(GL10.GL_BLEND);\r
- gl.glBlendFunc(GL10.GL_SRC_ALPHA, GL10.GL_ONE_MINUS_SRC_ALPHA);\r
+ Gdx.gl.glEnable(GL10.GL_BLEND);\r
+ Gdx.gl.glBlendFunc(GL10.GL_SRC_ALPHA, GL10.GL_ONE_MINUS_SRC_ALPHA);\r
for (int i = 0; i < LAYERS; i++) {\r
SpriteCache cache = caches[i];\r
cache.setProjectionMatrix(cam.combined);\r
cache.end();\r
}\r
\r
- renderer.begin(GL10.GL_LINES);\r
- renderer.color(1, 0, 0, 1);\r
- renderer.vertex(0, 0, 0);\r
- renderer.color(1, 0, 0, 1);\r
- renderer.vertex(500, 0, 0);\r
- renderer.color(0, 1, 0, 1);\r
- renderer.vertex(0, 0, 0);\r
- renderer.color(0, 1, 0, 1);\r
- renderer.vertex(0, 500, 0);\r
-\r
- renderer.color(0, 0, 1, 1);\r
- renderer.vertex(0, BOUND_Y, 0);\r
- renderer.color(0, 0, 1, 1);\r
- renderer.vertex(BOUND_X, BOUND_Y, 0);\r
-\r
- renderer.color(0, 0, 1, 1);\r
- renderer.vertex(BOUND_X, 0, 0);\r
- renderer.color(0, 0, 1, 1);\r
- renderer.vertex(BOUND_X, BOUND_Y, 0);\r
+ renderer.setProjectionMatrix(cam.combined);\r
+ renderer.begin(ShapeType.Line);\r
+ renderer.setColor(1, 0, 0, 1);\r
+ renderer.line(0, 0, 500, 0);\r
+ renderer.line(0, 0, 0, 500);\r
+\r
+ renderer.setColor(0, 0, 1, 1);\r
+ renderer.line(0, BOUND_Y, BOUND_X, BOUND_Y);\r
+\r
+ renderer.setColor(0, 0, 1, 1);\r
+ renderer.line(BOUND_X, 0, BOUND_X, BOUND_Y);\r
\r
renderer.end();\r
}\r
import com.badlogic.gdx.graphics.g3d.loaders.md5.MD5Model;\r
import com.badlogic.gdx.graphics.g3d.loaders.md5.MD5Renderer;\r
import com.badlogic.gdx.tests.utils.GdxTest;\r
+import com.badlogic.gdx.utils.TimeUtils;\r
\r
public class MD5Test extends GdxTest implements InputProcessor {\r
PerspectiveCamera camera;\r
renderer = new MD5Renderer(model, useNormals, false);\r
renderer.setSkeleton(model.baseSkeleton);\r
\r
- // long start = System.nanoTime();\r
+ // long start = TimeUtils.nanoTime();\r
// for( int i = 0; i < 100000; i++ )\r
// renderer.setSkeleton( model.baseSkeleton );\r
- // app.log( "MD5 Test", "took: " + (System.nanoTime() - start ) /\r
+ // app.log( "MD5 Test", "took: " + (TimeUtils.nanoTime() - start ) /\r
// 1000000000.0 );\r
\r
camera = new PerspectiveCamera(60, Gdx.graphics.getWidth(), Gdx.graphics.getHeight());\r
gl.glRotatef(angle, 0, 1, 0);\r
gl.glRotatef(-90, 1, 0, 0);\r
\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
MD5Animation.interpolate(anim.frames[animInfo.getCurrentFrame()], anim.frames[animInfo.getNextFrame()], skeleton,\r
animInfo.getInterpolation());\r
renderer.setSkeleton(skeleton);\r
- skinTime = (System.nanoTime() - start) / 1000000000.0f;\r
+ skinTime = (TimeUtils.nanoTime() - start) / 1000000000.0f;\r
\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
renderer.render();\r
- renderTime = (System.nanoTime() - start) / 1000000000.0f;\r
+ renderTime = (TimeUtils.nanoTime() - start) / 1000000000.0f;\r
gl.glPopMatrix();\r
}\r
\r
import com.badlogic.gdx.math.Vector3;\r
import com.badlogic.gdx.tests.utils.GdxTest;\r
import com.badlogic.gdx.utils.GdxRuntimeException;\r
+import com.badlogic.gdx.utils.TimeUtils;\r
\r
public class MatrixJNITest extends GdxTest {\r
@Override\r
Matrix4 mata = new Matrix4();\r
Matrix4 matb = new Matrix4();\r
\r
- long start = System.nanoTime();\r
+ long start = TimeUtils.nanoTime();\r
for (int i = 0; i < 1000000; i++) {\r
mata.mul(matb);\r
}\r
- Gdx.app.log("MatrixJNITest", "java matrix * matrix took: " + (System.nanoTime() - start) / 1000000000.0f);\r
+ Gdx.app.log("MatrixJNITest", "java matrix * matrix took: " + (TimeUtils.nanoTime() - start) / 1000000000.0f);\r
\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
for (int i = 0; i < 1000000; i++) {\r
Matrix4.mul(mata.val, matb.val);\r
}\r
- Gdx.app.log("MatrixJNITest", "jni matrix * matrix took: " + (System.nanoTime() - start) / 1000000000.0f);\r
+ Gdx.app.log("MatrixJNITest", "jni matrix * matrix took: " + (TimeUtils.nanoTime() - start) / 1000000000.0f);\r
\r
Vector3 vec = new Vector3();\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
for (int i = 0; i < 500000; i++) {\r
vec.mul(mata);\r
}\r
- Gdx.app.log("MatrixJNITest", "java vecs * matrix took: " + (System.nanoTime() - start) / 1000000000.0f);\r
+ Gdx.app.log("MatrixJNITest", "java vecs * matrix took: " + (TimeUtils.nanoTime() - start) / 1000000000.0f);\r
\r
float[] fvec = new float[3];\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
for (int i = 0; i < 500000; i++) {\r
Matrix4.mulVec(mata.val, fvec);\r
}\r
- Gdx.app.log("MatrixJNITest", "jni vecs * matrix took: " + (System.nanoTime() - start) / 1000000000.0f);\r
+ Gdx.app.log("MatrixJNITest", "jni vecs * matrix took: " + (TimeUtils.nanoTime() - start) / 1000000000.0f);\r
\r
float[] fvecs = new float[3 * 500000];\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
Matrix4.mulVec(mata.val, fvecs, 0, 500000, 3);\r
- Gdx.app.log("MatrixJNITest", "jni bulk vecs * matrix took: " + (System.nanoTime() - start) / 1000000000.0f);\r
+ Gdx.app.log("MatrixJNITest", "jni bulk vecs * matrix took: " + (TimeUtils.nanoTime() - start) / 1000000000.0f);\r
\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
for (int i = 0; i < 1000000; i++) {\r
mata.inv();\r
}\r
- Gdx.app.log("MatrixJNITest", "java inv(matrix): " + (System.nanoTime() - start) / 1000000000.0f);\r
+ Gdx.app.log("MatrixJNITest", "java inv(matrix): " + (TimeUtils.nanoTime() - start) / 1000000000.0f);\r
\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
for (int i = 0; i < 1000000; i++) {\r
Matrix4.inv(mata.val);\r
}\r
- Gdx.app.log("MatrixJNITest", "jni inv(matrix): " + (System.nanoTime() - start) / 1000000000.0f);\r
+ Gdx.app.log("MatrixJNITest", "jni inv(matrix): " + (TimeUtils.nanoTime() - start) / 1000000000.0f);\r
}\r
\r
private void check (Vector3 vec, float[] fvec) {\r
shader = new ShaderProgram(vertexShader, fragmentShader);\r
if (shader.isCompiled() == false) {\r
Gdx.app.log("ShaderTest", shader.getLog());\r
- System.exit(0);\r
+ Gdx.app.exit();\r
}\r
\r
mesh = new Mesh(true, 4, 6, VertexAttribute.Position(), VertexAttribute.ColorUnpacked(), VertexAttribute.TexCoords(0));\r
import com.badlogic.gdx.graphics.GL10;\r
import com.badlogic.gdx.graphics.OrthographicCamera;\r
import com.badlogic.gdx.graphics.glutils.ImmediateModeRenderer10;\r
+import com.badlogic.gdx.graphics.glutils.ShapeRenderer;\r
+import com.badlogic.gdx.graphics.glutils.ShapeRenderer.ShapeType;\r
import com.badlogic.gdx.tests.utils.GdxTest;\r
+import com.badlogic.gdx.utils.TimeUtils;\r
\r
-public class MultitouchTest extends GdxTest implements InputProcessor {\r
- ImmediateModeRenderer10 renderer;\r
+public class MultitouchTest extends GdxTest {\r
+ ShapeRenderer renderer;\r
OrthographicCamera camera;\r
- long startTime = System.nanoTime();\r
+ long startTime = TimeUtils.nanoTime();\r
\r
Color[] colors = {Color.RED, Color.BLUE, Color.GREEN, Color.WHITE};\r
\r
@Override\r
public void render () {\r
- Gdx.graphics.getGL10().glClear(GL10.GL_COLOR_BUFFER_BIT);\r
- Gdx.graphics.getGL10().glViewport(0, 0, Gdx.graphics.getWidth(), Gdx.graphics.getHeight());\r
+ Gdx.gl.glClear(GL10.GL_COLOR_BUFFER_BIT);\r
camera.update();\r
- camera.apply(Gdx.gl10);\r
- renderer.begin(GL10.GL_TRIANGLES);\r
+ renderer.setProjectionMatrix(camera.combined);\r
+ renderer.begin(ShapeType.FilledTriangle);\r
int size = Math.max(Gdx.graphics.getWidth(), Gdx.graphics.getHeight()) / 10;\r
for (int i = 0; i < 10; i++) {\r
if (Gdx.input.isTouched(i) == false) continue;\r
float x = Gdx.input.getX(i);\r
float y = Gdx.graphics.getHeight() - Gdx.input.getY(i) - 1;\r
Color col = colors[i % colors.length];\r
- renderer.color(col.r, col.g, col.b, col.a);\r
- renderer.vertex(x, y + size, 0);\r
- renderer.color(col.r, col.g, col.b, col.a);\r
- renderer.vertex(x + size, y - size, 0);\r
- renderer.color(col.r, col.g, col.b, col.a);\r
- renderer.vertex(x - size, y - size, 0);\r
+ renderer.filledTriangle(x, y + size, x + size, y - size, x - size, y - size);\r
}\r
-\r
renderer.end();\r
-\r
-// if (System.nanoTime() - startTime > 1000000000l) {\r
-// Gdx.app.log("MultiTouhTest", "fps:" + Gdx.graphics.getFramesPerSecond());\r
-// startTime = System.nanoTime();\r
-// }\r
}\r
\r
@Override\r
public void create () {\r
Gdx.app.log("Multitouch", "multitouch supported: " + Gdx.input.isPeripheralAvailable(Peripheral.MultitouchScreen));\r
- renderer = new ImmediateModeRenderer10();\r
+ renderer = new ShapeRenderer();\r
camera = new OrthographicCamera(Gdx.graphics.getWidth(), Gdx.graphics.getHeight());\r
camera.position.set(Gdx.graphics.getWidth() / 2.0f, Gdx.graphics.getHeight() / 2.0f, 0);\r
Gdx.input.setInputProcessor(this);\r
}\r
-\r
- @Override\r
- public boolean keyDown (int keycode) {\r
- return false;\r
- }\r
-\r
- @Override\r
- public boolean keyTyped (char character) {\r
- return false;\r
- }\r
-\r
- @Override\r
- public boolean keyUp (int keycode) {\r
- return false;\r
- }\r
-\r
- @Override\r
- public boolean touchDown (int x, int y, int pointer, int newParam) {\r
-// Gdx.app.log("Multitouch", "down: " + pointer);\r
- return false;\r
- }\r
-\r
- @Override\r
- public boolean touchDragged (int x, int y, int pointer) {\r
-// Gdx.app.log("Multitouch", "drag: " + pointer);\r
- return false;\r
- }\r
-\r
- @Override\r
- public boolean touchUp (int x, int y, int pointer, int button) {\r
-// Gdx.app.log("Multitouch", "up: " + pointer);\r
- return false;\r
- }\r
-\r
- @Override\r
- public boolean needsGL20 () {\r
- return false;\r
- }\r
-\r
- @Override\r
- public boolean touchMoved (int x, int y) {\r
- return false;\r
- }\r
-\r
- @Override\r
- public boolean scrolled (int amount) {\r
- return false;\r
- }\r
}\r
@Override\r
public void create () {\r
for (int i = 0; i < music.length; i++) {\r
- music[i] = Gdx.audio.newMusic(Gdx.files.internal("data/music.mp3"));\r
+ music[i] = Gdx.audio.newMusic(Gdx.files.internal("data/cloudconnected.ogg"));\r
}\r
\r
buttons = new TextureRegion(new Texture(Gdx.files.internal("data/playback.png")));\r
controller = new OrthoCamController(camera);\r
Gdx.input.setInputProcessor(controller);\r
batch = new SpriteBatch();\r
- font = new BitmapFont();\r
+ font = new BitmapFont(Gdx.files.internal("data/arial-15.fnt"), false);\r
}\r
\r
@Override\r
public void render () {\r
spriteBatch.getProjectionMatrix().setToOrtho2D(0, 0, Gdx.graphics.getWidth(), Gdx.graphics.getHeight());\r
float delta = Gdx.graphics.getDeltaTime();\r
- GL10 gl = Gdx.graphics.getGL10();\r
- gl.glClear(GL10.GL_COLOR_BUFFER_BIT);\r
+ Gdx.gl.glClear(GL10.GL_COLOR_BUFFER_BIT);\r
spriteBatch.begin();\r
effect.draw(spriteBatch, delta);\r
spriteBatch.end();\r
\r
@Override\r
public void create () {\r
- font = new BitmapFont();\r
+ font = new BitmapFont(Gdx.files.internal("data/arial-15.fnt"), false);\r
batch = new SpriteBatch();\r
texture = new Texture(Gdx.files.internal("data/badlogicsmall.jpg"));\r
}\r
\r
public void render () {\r
- Gdx.gl10.glClear(GL10.GL_COLOR_BUFFER_BIT);\r
+ Gdx.gl.glClear(GL10.GL_COLOR_BUFFER_BIT);\r
\r
batch.begin();\r
float width = (int)(Gdx.graphics.getPpcX() * 2);\r
\r
@Override\r
public boolean needsGL20 () {\r
- return false;\r
+ return true;\r
}\r
\r
}\r
@Override\r
public void render () {\r
\r
- GL10 gl = Gdx.graphics.getGL10();\r
- gl.glClearColor(0, 1, 0, 1);\r
- gl.glClear(GL10.GL_COLOR_BUFFER_BIT);\r
+ Gdx.gl.glClearColor(0, 1, 0, 1);\r
+ Gdx.gl.glClear(GL10.GL_COLOR_BUFFER_BIT);\r
\r
spriteBatch.begin();\r
logoSprite.draw(spriteBatch);\r
import com.badlogic.gdx.Gdx;\r
import com.badlogic.gdx.graphics.GL10;\r
import com.badlogic.gdx.graphics.Pixmap;\r
-import com.badlogic.gdx.graphics.PixmapIO;\r
import com.badlogic.gdx.graphics.Texture;\r
import com.badlogic.gdx.graphics.g2d.SpriteBatch;\r
import com.badlogic.gdx.graphics.g2d.TextureRegion;\r
TextureRegion region;\r
\r
public void create () {\r
- pixmap = new Pixmap(2, 2, Pixmap.Format.RGBA8888);\r
- pixmap.setColor(1, 0, 0, 1);\r
- pixmap.fill();\r
- PixmapIO.writePNG(Gdx.files.absolute("test.png"), pixmap);\r
- pixmap.dispose();\r
- \r
// Create an empty dynamic pixmap\r
pixmap = new Pixmap(800, 480, Pixmap.Format.RGBA8888); // Pixmap.Format.RGBA8888);\r
\r
controller = new PerspectiveCamController(cam);\r
Gdx.input.setInputProcessor(controller);\r
batch = new SpriteBatch();\r
- font = new BitmapFont();\r
+ font = new BitmapFont(Gdx.files.internal("data/arial-15.fnt"), false);\r
}\r
\r
public void render () {\r
import com.badlogic.gdx.math.Vector2;\r
import com.badlogic.gdx.tests.utils.GdxTest;\r
\r
-public class SimpleAnimationTest extends GdxTest implements InputProcessor {\r
+public class SimpleAnimationTest extends GdxTest {\r
\r
@Override\r
public boolean needsGL20 () {\r
@Override\r
public boolean touchDown (int x, int y, int pointer, int button) {\r
position.x = x;\r
- position.y = y;\r
- // System.out.println(position);\r
+ position.y = Gdx.graphics.getHeight() - y;\r
return true;\r
}\r
-\r
- @Override\r
- public boolean keyDown (int keycode) {\r
- // TODO Auto-generated method stub\r
- return false;\r
- }\r
-\r
- @Override\r
- public boolean keyUp (int keycode) {\r
- // TODO Auto-generated method stub\r
- return false;\r
- }\r
-\r
- @Override\r
- public boolean keyTyped (char character) {\r
- // TODO Auto-generated method stub\r
- return false;\r
- }\r
-\r
- @Override\r
- public boolean touchUp (int x, int y, int pointer, int button) {\r
- // TODO Auto-generated method stub\r
- return false;\r
- }\r
-\r
- @Override\r
- public boolean touchDragged (int x, int y, int pointer) {\r
- // TODO Auto-generated method stub\r
- return false;\r
- }\r
-\r
- @Override\r
- public boolean touchMoved (int x, int y) {\r
- // TODO Auto-generated method stub\r
- return false;\r
- }\r
-\r
- @Override\r
- public boolean scrolled (int amount) {\r
- // TODO Auto-generated method stub\r
- return false;\r
- }\r
}\r
+++ /dev/null
-/*******************************************************************************\r
- * Copyright 2011 See AUTHORS file.\r
- * \r
- * Licensed under the Apache License, Version 2.0 (the "License");\r
- * you may not use this file except in compliance with the License.\r
- * You may obtain a copy of the License at\r
- * \r
- * http://www.apache.org/licenses/LICENSE-2.0\r
- * \r
- * Unless required by applicable law or agreed to in writing, software\r
- * distributed under the License is distributed on an "AS IS" BASIS,\r
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
- * See the License for the specific language governing permissions and\r
- * limitations under the License.\r
- ******************************************************************************/\r
-\r
-package com.badlogic.gdx.tests;\r
-\r
-import com.badlogic.gdx.Gdx;\r
-import com.badlogic.gdx.InputProcessor;\r
-import com.badlogic.gdx.graphics.GL10;\r
-import com.badlogic.gdx.tests.utils.GdxTest;\r
-\r
-public class SimpleTest extends GdxTest implements InputProcessor {\r
- float r = 1, g = 0, b = 0;\r
-\r
- @Override\r
- public void create () {\r
- Gdx.app.log("Simple Test", "Thread=" + Thread.currentThread().getId() + ", surface created");\r
- Gdx.input.setInputProcessor(this);\r
- }\r
-\r
- @Override\r
- public void render () {\r
- GL10 gl = Gdx.app.getGraphics().getGL10();\r
-\r
- gl.glClearColor(r, g, b, 1);\r
- gl.glClear(GL10.GL_COLOR_BUFFER_BIT);\r
- }\r
-\r
- @Override\r
- public void dispose () {\r
- Gdx.app.log("Simple Test", "Thread=" + Thread.currentThread().getId() + ", application destroyed");\r
- }\r
-\r
- @Override\r
- public boolean keyDown (int keycode) {\r
- return false;\r
- }\r
-\r
- @Override\r
- public boolean keyTyped (char character) {\r
- return false;\r
- }\r
-\r
- @Override\r
- public boolean keyUp (int keycode) {\r
- return false;\r
- }\r
-\r
- @Override\r
- public boolean touchDown (int x, int y, int pointer, int newParam) {\r
- return false;\r
- }\r
-\r
- @Override\r
- public boolean touchDragged (int x, int y, int pointer) {\r
- return false;\r
- }\r
-\r
- @Override\r
- public boolean touchUp (int x, int y, int pointer, int button) {\r
- r = (float)Math.random();\r
- g = (float)Math.random();\r
- b = (float)Math.random();\r
- return false;\r
- }\r
-\r
- @Override\r
- public void pause () {\r
- }\r
-\r
- @Override\r
- public void resume () {\r
- }\r
-\r
- @Override\r
- public boolean needsGL20 () {\r
- return false;\r
- }\r
-\r
- @Override\r
- public boolean touchMoved (int x, int y) {\r
- return false;\r
- }\r
-\r
- @Override\r
- public boolean scrolled (int amount) {\r
- return false;\r
- }\r
-}\r
import com.badlogic.gdx.graphics.Texture;\r
import com.badlogic.gdx.graphics.g2d.SpriteBatch;\r
import com.badlogic.gdx.tests.utils.GdxTest;\r
+import com.badlogic.gdx.utils.TimeUtils;\r
\r
public class SpriteBatchShaderTest extends GdxTest {\r
int SPRITES = 400;\r
\r
- long startTime = System.nanoTime();\r
+ long startTime = TimeUtils.nanoTime();\r
int frames = 0;\r
\r
Texture texture;\r
float draw2 = 0;\r
float drawText = 0;\r
\r
- long start = System.nanoTime();\r
+ long start = TimeUtils.nanoTime();\r
spriteBatch.begin();\r
- begin = (System.nanoTime() - start) / 1000000000.0f;\r
+ begin = (TimeUtils.nanoTime() - start) / 1000000000.0f;\r
\r
int len = coords.length;\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
for (int i = 0; i < len; i += 2)\r
spriteBatch.draw(texture, coords[i], coords[i + 1], 0, 0, 32, 32);\r
- draw1 = (System.nanoTime() - start) / 1000000000.0f;\r
+ draw1 = (TimeUtils.nanoTime() - start) / 1000000000.0f;\r
\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
spriteBatch.setColor(col);\r
for (int i = 0; i < coords2.length; i += 2)\r
spriteBatch.draw(texture2, coords2[i], coords2[i + 1], 0, 0, 32, 32);\r
- draw2 = (System.nanoTime() - start) / 1000000000.0f;\r
+ draw2 = (TimeUtils.nanoTime() - start) / 1000000000.0f;\r
\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
// spriteBatch.drawText(font, "Question?", 100, 300, Color.RED);\r
// spriteBatch.drawText(font, "and another this is a test", 200, 100, Color.WHITE);\r
// spriteBatch.drawText(font, "all hail and another this is a test", 200, 200, Color.WHITE);\r
- drawText = (System.nanoTime() - start) / 1000000000.0f;\r
+ drawText = (TimeUtils.nanoTime() - start) / 1000000000.0f;\r
\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
spriteBatch.end();\r
- end = (System.nanoTime() - start) / 1000000000.0f;\r
+ end = (TimeUtils.nanoTime() - start) / 1000000000.0f;\r
\r
- if (System.nanoTime() - startTime > 1000000000) {\r
+ if (TimeUtils.nanoTime() - startTime > 1000000000) {\r
Gdx.app.log("SpriteBatch", "fps: " + frames + ", render calls: " + spriteBatch.renderCalls + ", " + begin + ", " + draw1\r
+ ", " + draw2 + ", " + drawText + ", " + end);\r
frames = 0;\r
- startTime = System.nanoTime();\r
+ startTime = TimeUtils.nanoTime();\r
}\r
frames++;\r
}\r
@Override\r
public void create () {\r
spriteBatch = new SpriteBatch();\r
- Pixmap pixmap = new Pixmap(Gdx.files.internal("data/badlogicsmall.jpg"));\r
-// pixmap.setColor( 0, 0, 0, 0 );\r
-// pixmap.fillCircle( 16, 16, 4 );\r
- texture = new Texture(32, 32, Format.RGB565);\r
- texture.draw(pixmap, 0, 0);\r
- pixmap.dispose();\r
+ texture = new Texture(Gdx.files.internal("data/badlogicsmall.jpg"));\r
\r
- pixmap = new Pixmap(32, 32, Format.RGB565);\r
+ Pixmap pixmap = new Pixmap(32, 32, Format.RGB565);\r
pixmap.setColor(1, 1, 0, 0.7f);\r
pixmap.fill();\r
-// pixmap.setColor( 0, 0, 0, 0 );\r
-// pixmap.fillCircle( 16, 16, 4 );\r
-//\r
texture2 = new Texture(pixmap);\r
pixmap.dispose();\r
\r
-// if (font == null) font = Gdx.graphics.newFont("Arial", 32, FontStyle.Plain);\r
-\r
for (int i = 0; i < coords.length; i += 2) {\r
coords[i] = (int)(Math.random() * Gdx.graphics.getWidth());\r
coords[i + 1] = (int)(Math.random() * Gdx.graphics.getHeight());\r
import com.badlogic.gdx.graphics.g2d.Sprite;\r
import com.badlogic.gdx.graphics.g2d.SpriteBatch;\r
import com.badlogic.gdx.tests.utils.GdxTest;\r
+import com.badlogic.gdx.utils.TimeUtils;\r
\r
public class SpriteBatchTest extends GdxTest implements InputProcessor {\r
int SPRITES = 100 / 2;\r
\r
- long startTime = System.nanoTime();\r
+ long startTime = TimeUtils.nanoTime();\r
int frames = 0;\r
\r
Texture texture;\r
SCALE_SPEED = -1;\r
}\r
\r
- long start = System.nanoTime();\r
+ long start = TimeUtils.nanoTime();\r
spriteBatch.begin();\r
- begin = (System.nanoTime() - start) / 1000000000.0f;\r
+ begin = (TimeUtils.nanoTime() - start) / 1000000000.0f;\r
\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
for (int i = 0; i < sprites.length; i += 6)\r
spriteBatch.draw(texture, sprites[i], sprites[i + 1], 16, 16, 32, 32, scale, scale, angle, 0, 0, 32, 32, false, false);\r
- draw1 = (System.nanoTime() - start) / 1000000000.0f;\r
+ draw1 = (TimeUtils.nanoTime() - start) / 1000000000.0f;\r
\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
for (int i = 0; i < sprites2.length; i += 6)\r
spriteBatch\r
.draw(texture2, sprites2[i], sprites2[i + 1], 16, 16, 32, 32, scale, scale, angle, 0, 0, 32, 32, false, false);\r
- draw2 = (System.nanoTime() - start) / 1000000000.0f;\r
+ draw2 = (TimeUtils.nanoTime() - start) / 1000000000.0f;\r
\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
// spriteBatch.drawText(font, "Question?", 100, 300, Color.RED);\r
// spriteBatch.drawText(font, "and another this is a test", 200, 100, Color.WHITE);\r
// spriteBatch.drawText(font, "all hail and another this is a test", 200, 200, Color.WHITE);\r
// spriteBatch.drawText(font, "normal fps: " + Gdx.graphics.getFramesPerSecond(), 10, 30, Color.RED);\r
- drawText = (System.nanoTime() - start) / 1000000000.0f;\r
+ drawText = (TimeUtils.nanoTime() - start) / 1000000000.0f;\r
\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
spriteBatch.end();\r
- end = (System.nanoTime() - start) / 1000000000.0f;\r
+ end = (TimeUtils.nanoTime() - start) / 1000000000.0f;\r
\r
- if (System.nanoTime() - startTime > 1000000000) {\r
+ if (TimeUtils.nanoTime() - startTime > 1000000000) {\r
Gdx.app.log("SpriteBatch", "fps: " + frames + ", render calls: " + spriteBatch.renderCalls + ", " + begin + ", " + draw1\r
+ ", " + draw2 + ", " + drawText + ", " + end);\r
frames = 0;\r
- startTime = System.nanoTime();\r
+ startTime = TimeUtils.nanoTime();\r
}\r
frames++;\r
\r
float draw2 = 0;\r
float drawText = 0;\r
\r
- long start = System.nanoTime();\r
+ long start = TimeUtils.nanoTime();\r
spriteBatch.begin();\r
- begin = (System.nanoTime() - start) / 1000000000.0f;\r
+ begin = (TimeUtils.nanoTime() - start) / 1000000000.0f;\r
\r
float angleInc = ROTATION_SPEED * Gdx.graphics.getDeltaTime();\r
scale += SCALE_SPEED * Gdx.graphics.getDeltaTime();\r
SCALE_SPEED = -1;\r
}\r
\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
for (int i = 0; i < SPRITES; i++) {\r
if (angleInc != 0) sprites3[i].rotate(angleInc); // this is aids\r
if (scale != 1) sprites3[i].setScale(scale); // this is aids\r
sprites3[i].draw(spriteBatch);\r
}\r
- draw1 = (System.nanoTime() - start) / 1000000000.0f;\r
+ draw1 = (TimeUtils.nanoTime() - start) / 1000000000.0f;\r
\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
for (int i = SPRITES; i < SPRITES << 1; i++) {\r
if (angleInc != 0) sprites3[i].rotate(angleInc); // this is aids\r
if (scale != 1) sprites3[i].setScale(scale); // this is aids\r
sprites3[i].draw(spriteBatch);\r
}\r
- draw2 = (System.nanoTime() - start) / 1000000000.0f;\r
+ draw2 = (TimeUtils.nanoTime() - start) / 1000000000.0f;\r
\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
// spriteBatch.drawText(font, "Question?", 100, 300, Color.RED);\r
// spriteBatch.drawText(font, "and another this is a test", 200, 100, Color.WHITE);\r
// spriteBatch.drawText(font, "all hail and another this is a test", 200, 200, Color.WHITE);\r
// spriteBatch.drawText(font, "Sprite fps: " + Gdx.graphics.getFramesPerSecond(), 10, 30, Color.RED);\r
- drawText = (System.nanoTime() - start) / 1000000000.0f;\r
+ drawText = (TimeUtils.nanoTime() - start) / 1000000000.0f;\r
\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
spriteBatch.end();\r
- end = (System.nanoTime() - start) / 1000000000.0f;\r
+ end = (TimeUtils.nanoTime() - start) / 1000000000.0f;\r
\r
- if (System.nanoTime() - startTime > 1000000000) {\r
+ if (TimeUtils.nanoTime() - startTime > 1000000000) {\r
Gdx.app.log("SpriteBatch", "fps: " + frames + ", render calls: " + spriteBatch.renderCalls + ", " + begin + ", " + draw1\r
+ ", " + draw2 + ", " + drawText + ", " + end);\r
frames = 0;\r
- startTime = System.nanoTime();\r
+ startTime = TimeUtils.nanoTime();\r
}\r
frames++;\r
}\r
import com.badlogic.gdx.graphics.g2d.SpriteCache;\r
import com.badlogic.gdx.math.MathUtils;\r
import com.badlogic.gdx.tests.utils.GdxTest;\r
+import com.badlogic.gdx.utils.TimeUtils;\r
\r
public class SpriteCacheTest extends GdxTest implements InputProcessor {\r
int SPRITES = 400 / 2;\r
\r
- long startTime = System.nanoTime();\r
+ long startTime = TimeUtils.nanoTime();\r
int frames = 0;\r
\r
Texture texture;\r
float end = 0;\r
float draw1 = 0;\r
\r
- long start = System.nanoTime();\r
+ long start = TimeUtils.nanoTime();\r
spriteCache.begin();\r
- begin = (System.nanoTime() - start) / 1000000000.0f;\r
+ begin = (TimeUtils.nanoTime() - start) / 1000000000.0f;\r
\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
spriteCache.draw(normalCacheID);\r
- draw1 = (System.nanoTime() - start) / 1000000000.0f;\r
+ draw1 = (TimeUtils.nanoTime() - start) / 1000000000.0f;\r
\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
spriteCache.end();\r
- end = (System.nanoTime() - start) / 1000000000.0f;\r
+ end = (TimeUtils.nanoTime() - start) / 1000000000.0f;\r
\r
- if (System.nanoTime() - startTime > 1000000000) {\r
+ if (TimeUtils.nanoTime() - startTime > 1000000000) {\r
// Gdx.app.log( "SpriteBatch", "fps: " + frames + ", render calls: " + spriteBatch.renderCalls + ", " + begin + ", " + draw1 +\r
// ", " + draw2 + ", " + drawText + ", " + end );\r
frames = 0;\r
- startTime = System.nanoTime();\r
+ startTime = TimeUtils.nanoTime();\r
}\r
frames++;\r
}\r
float draw2 = 0;\r
float drawText = 0;\r
\r
- long start = System.nanoTime();\r
+ long start = TimeUtils.nanoTime();\r
spriteCache.begin();\r
- begin = (System.nanoTime() - start) / 1000000000.0f;\r
+ begin = (TimeUtils.nanoTime() - start) / 1000000000.0f;\r
\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
spriteCache.draw(spriteCacheID);\r
- draw1 = (System.nanoTime() - start) / 1000000000.0f;\r
+ draw1 = (TimeUtils.nanoTime() - start) / 1000000000.0f;\r
\r
- start = System.nanoTime();\r
+ start = TimeUtils.nanoTime();\r
spriteCache.end();\r
- end = (System.nanoTime() - start) / 1000000000.0f;\r
+ end = (TimeUtils.nanoTime() - start) / 1000000000.0f;\r
\r
- if (System.nanoTime() - startTime > 1000000000) {\r
+ if (TimeUtils.nanoTime() - startTime > 1000000000) {\r
// Gdx.app.log( "SpriteBatch", "fps: " + frames + ", render calls: " + spriteBatch.renderCalls + ", " + begin + ", " + draw1 +\r
// ", " + draw2 + ", " + drawText + ", " + end );\r
frames = 0;\r
- startTime = System.nanoTime();\r
+ startTime = TimeUtils.nanoTime();\r
}\r
frames++;\r
}\r
public void create () {\r
spriteCache = new SpriteCache(1000, true);\r
\r
- Pixmap pixmap = new Pixmap(Gdx.files.internal("data/badlogicsmall.jpg"));\r
- texture = new Texture(32, 32, Format.RGB565);\r
+ Texture texture = new Texture(Gdx.files.internal("data/badlogicsmall.jpg"));\r
texture.setFilter(TextureFilter.Linear, TextureFilter.Linear);\r
- texture.draw(pixmap, 0, 0);\r
- pixmap.dispose();\r
\r
- pixmap = new Pixmap(32, 32, Format.RGBA8888);\r
+ Pixmap pixmap = new Pixmap(32, 32, Format.RGBA8888);\r
pixmap.setColor(1, 1, 0, 0.5f);\r
pixmap.fill();\r
texture2 = new Texture(pixmap);\r
import com.badlogic.gdx.graphics.g2d.SpriteBatch;\r
import com.badlogic.gdx.graphics.g2d.SpriteCache;\r
import com.badlogic.gdx.tests.utils.GdxTest;\r
+import com.badlogic.gdx.utils.TimeUtils;\r
\r
public class SpritePerformanceTest extends GdxTest {\r
StringBuilder log = new StringBuilder();\r
}\r
int spritesHandle = cache.endCache();\r
\r
- startTime = System.nanoTime();\r
+ startTime = TimeUtils.nanoTime();\r
frames = 0;\r
}\r
\r
}\r
\r
frames++;\r
- if (System.nanoTime() - startTime > 5000000000l) {\r
+ if (TimeUtils.nanoTime() - startTime > 5000000000l) {\r
Gdx.app.log("SpritePerformanceTest", "mode: " + modes[mode] + ", fps: " + frames / 5.0f);\r
log.append("mode: " + modes[mode] + ", fps: " + frames / 5.0f + "\n");\r
frames = 0;\r
- startTime = System.nanoTime();\r
+ startTime = TimeUtils.nanoTime();\r
mode++;\r
if (mode > 9) mode = 0;\r
}\r
import com.badlogic.gdx.math.Vector3;\r
import com.badlogic.gdx.math.collision.Ray;\r
import com.badlogic.gdx.tests.utils.GdxTest;\r
+import com.badlogic.gdx.utils.TimeUtils;\r
\r
public class TerrainTest extends GdxTest {\r
ImmediateModeRenderer10 renderer;\r
PerspectiveCamera camera;\r
Vector3 intersection = new Vector3();\r
boolean intersected = false;\r
- long lastTime = System.nanoTime();\r
+ long lastTime = TimeUtils.nanoTime();\r
\r
@Override\r
public void create () {\r
\r
handleInput(Gdx.input, Gdx.graphics.getDeltaTime());\r
\r
- if (System.nanoTime() - lastTime > 1000000000) {\r
+ if (TimeUtils.nanoTime() - lastTime > 1000000000) {\r
Gdx.app.log("TerrainTest", "fps: " + Gdx.graphics.getFramesPerSecond());\r
- lastTime = System.nanoTime();\r
+ lastTime = TimeUtils.nanoTime();\r
}\r
}\r
\r
+++ /dev/null
-package com.badlogic.gdx.tests;\r
-\r
-public class TextureBindTestGL2 extends TextureBindTest {\r
- @Override\r
- public boolean needsGL20() {\r
- return true;\r
- }\r
-}\r
+++ /dev/null
-/*******************************************************************************\r
- * Copyright 2011 See AUTHORS file.\r
- * \r
- * Licensed under the Apache License, Version 2.0 (the "License");\r
- * you may not use this file except in compliance with the License.\r
- * You may obtain a copy of the License at\r
- * \r
- * http://www.apache.org/licenses/LICENSE-2.0\r
- * \r
- * Unless required by applicable law or agreed to in writing, software\r
- * distributed under the License is distributed on an "AS IS" BASIS,\r
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
- * See the License for the specific language governing permissions and\r
- * limitations under the License.\r
- ******************************************************************************/\r
-\r
-package com.badlogic.gdx.tests;\r
-\r
-public class TexturePackerAtlasTest {\r
-\r
-}\r
import com.badlogic.gdx.graphics.glutils.VertexBufferObjectSubData;\r
import com.badlogic.gdx.graphics.glutils.VertexData;\r
import com.badlogic.gdx.tests.utils.GdxTest;\r
+import com.badlogic.gdx.utils.TimeUtils;\r
\r
public class VBOVATest extends GdxTest {\r
\r
indices[i] = (short)i;\r
}\r
\r
- startTime = System.nanoTime();\r
+ startTime = TimeUtils.nanoTime();\r
}\r
\r
@Override\r
vertexBuffer.unbind();\r
}\r
\r
- long endTime = System.nanoTime();\r
+ long endTime = TimeUtils.nanoTime();\r
if (endTime - startTime >= 4000000000l) {\r
double secs = (endTime - startTime) / 1000000000.0;\r
double fps = frames / secs;\r
- Gdx.app.log("VBOVATest", vertexBuffer.getClass().getSimpleName() + ", " + isStatic + ", " + (mode > 2) + ", " + fps);\r
+ Gdx.app.log("VBOVATest", vertexBuffer.getClass().getName() + ", " + isStatic + ", " + (mode > 2) + ", " + fps);\r
mode++;\r
if (mode > 5) {\r
mode = 0;\r
isStatic = !isStatic;\r
}\r
- startTime = System.nanoTime();\r
+ startTime = TimeUtils.nanoTime();\r
frames = 0;\r
}\r
\r
import com.badlogic.gdx.graphics.Texture;\r
import com.badlogic.gdx.graphics.VertexAttribute;\r
import com.badlogic.gdx.graphics.VertexAttributes;\r
+import com.badlogic.gdx.graphics.glutils.IndexBufferObject;\r
import com.badlogic.gdx.graphics.glutils.ShaderProgram;\r
import com.badlogic.gdx.graphics.glutils.VertexBufferObject;\r
import com.badlogic.gdx.tests.utils.GdxTest;\r
Texture texture;\r
ShaderProgram shader;\r
VertexBufferObject vbo;\r
- ShortBuffer indices;\r
+ IndexBufferObject indices;\r
\r
@Override\r
public boolean needsGL20 () {\r
public void render () {\r
GL20 gl = Gdx.gl20;\r
gl.glViewport(0, 0, Gdx.graphics.getWidth(), Gdx.graphics.getHeight());\r
+ Gdx.gl.glClearColor(0.7f, 0, 0, 1);\r
gl.glClear(GL20.GL_COLOR_BUFFER_BIT);\r
\r
gl.glEnable(GL20.GL_TEXTURE_2D);\r
shader.setUniformi("u_texture", 0);\r
texture.bind();\r
vbo.bind(shader);\r
- gl.glDrawElements(GL20.GL_TRIANGLES, 3, GL20.GL_UNSIGNED_SHORT, indices);\r
+ indices.bind();\r
+ gl.glDrawElements(GL20.GL_TRIANGLES, 3, GL20.GL_UNSIGNED_SHORT, indices.getBuffer().position());\r
+ indices.unbind();\r
vbo.unbind(shader);\r
shader.end();\r
}\r
float[] vertices = new float[] {-1, -1, 0, 0, Color.toFloatBits(1f, 0f, 0f, 1f), 0, 1, 0.5f, 1.0f,\r
Color.toFloatBits(0f, 1f, 0f, 1f), 1, -1, 1, 0, Color.toFloatBits(0f, 0f, 1f, 1f)};\r
vbo.setVertices(vertices, 0, vertices.length);\r
- indices = BufferUtils.newShortBuffer(3);\r
- indices.put(new short[] {0, 1, 2});\r
- indices.flip();\r
+ indices = new IndexBufferObject(3);\r
+ indices.setIndices(new short[] {0, 1, 2}, 0, 3);\r
\r
texture = new Texture(Gdx.files.internal("data/badlogic.jpg"));\r
}\r
vbo.invalidate();\r
}\r
\r
-}\r
+}
\ No newline at end of file
import com.badlogic.gdx.math.Vector3;\r
import com.badlogic.gdx.math.collision.Ray;\r
import com.badlogic.gdx.tests.utils.GdxTest;\r
+import com.badlogic.gdx.utils.TimeUtils;\r
\r
public class WaterRipples extends GdxTest implements InputProcessor {\r
static final short WIDTH = 50;\r
}\r
}\r
\r
- long lastTick = System.nanoTime();\r
+ long lastTick = TimeUtils.nanoTime();\r
Random rand = new Random();\r
\r
@Override\r
public void create () {\r
// a bitmap font to draw some text, note that we\r
// pass true to the constructor, which flips glyphs on y\r
- font = new BitmapFont(true);\r
+ font = new BitmapFont(Gdx.files.internal("data/arial-15.fnt"), true);\r
\r
// a texture region, note the flipping on y again\r
region = new TextureRegion(new Texture("data/badlogic.jpg"));\r
PixmapTest.class, PreferencesTest.class,\r
ProjectiveTextureTest.class, Pong.class, ProjectTest.class,\r
RemoteTest.class, RotationTest.class, ShaderMultitextureTest.class,\r
- ShadowMappingTest.class, SplineTest.class, SimpleTest.class,\r
+ ShadowMappingTest.class, SplineTest.class,\r
SimpleAnimationTest.class, SimpleDecalTest.class,\r
SimpleStageCullingTest.class, SoundTest.class,\r
SpriteCacheTest.class, SpriteCacheOffsetTest.class,\r
VorbisTest.class, WaterRipples.class, HelloTriangle.class,\r
SimpleVertexShader.class, ShapeRendererTest.class,\r
MoveSpriteExample.class, StbTrueTypeTest.class, SoundTouchTest.class, Mpg123Test.class, WavTest.class,\r
- TextButtonTest.class, TextButtonTestGL2.class, TextureBindTest.class, TextureBindTestGL2.class,\r
+ TextButtonTest.class, TextButtonTestGL2.class, TextureBindTest.class,\r
SortedSpriteTest.class, ExternalMusicTest.class, SoftKeyboardTest.class, \r
DirtyRenderingTest.class, FreeTypeTest.class, YDownTest.class};\r
\r
OSDN Git Service
