Java 类com.badlogic.gdx.math.WindowedMean 实例源码

@Override
public FloatCounter read(Kryo kryo, Input input, Class<FloatCounter> type) {
    WindowedMean windowedMean = kryo.readObjectOrNull(input, WindowedMean.class);
    FloatCounter floatCounter = new FloatCounter(windowedMean == null ? 0 : windowedMean.getWindowSize());
    if (windowedMean != null) {
        float[] windowedMeanValues = windowedMean.getWindowValues();
        for (float f : windowedMeanValues) { // restores the private WindowedMean
            floatCounter.put(f);
        }
    }
    floatCounter.count = input.readInt();
    floatCounter.total = input.readFloat();
    floatCounter.min = input.readFloat();
    floatCounter.max = input.readFloat();
    floatCounter.average = input.readFloat();
    floatCounter.latest = input.readFloat();
    floatCounter.value = input.readFloat();
    return floatCounter;
}

@Override
public FloatCounter copy (Kryo kryo, FloatCounter original) {
    WindowedMean windowedMean = original.mean;
    FloatCounter floatCounter = new FloatCounter(windowedMean == null ? 0 : windowedMean.getWindowSize());
    if (windowedMean != null) {
        float[] windowedMeanValues = windowedMean.getWindowValues();
        for (float f : windowedMeanValues) { // restores the private WindowedMean
            floatCounter.put(f);
        }
    }
    floatCounter.count = original.count;
    floatCounter.total = original.total;
    floatCounter.min = original.min;
    floatCounter.max = original.max;
    floatCounter.average = original.average;
    floatCounter.latest = original.latest;
    floatCounter.value = original.value;
    return floatCounter;
}

@Override
public void onSurfaceCreated (javax.microedition.khronos.opengles.GL10 gl, EGLConfig config) {
    eglContext = ((EGL10)EGLContext.getEGL()).eglGetCurrentContext();
    setupGL(gl);
    logConfig(config);
    updatePpi();

    Mesh.invalidateAllMeshes(app);
    Texture.invalidateAllTextures(app);
    Cubemap.invalidateAllCubemaps(app);
    ShaderProgram.invalidateAllShaderPrograms(app);
    FrameBuffer.invalidateAllFrameBuffers(app);

    logManagedCachesStatus();

    Display display = app.getWindowManager().getDefaultDisplay();
    this.width = display.getWidth();
    this.height = display.getHeight();
    this.mean = new WindowedMean(5);
    this.lastFrameTime = System.nanoTime();

    gl.glViewport(0, 0, this.width, this.height);
}

public final void onSurfaceCreated(javax.microedition.khronos.opengles.GL10 paramGL10, EGLConfig paramEGLConfig)
{
  this.eglContext = ((EGL10)EGLContext.getEGL()).eglGetCurrentContext();
  setupGL(paramGL10);
  logConfig(paramEGLConfig);
  updatePpi();
  if (!this.isContextPreserved)
  {
    Mesh.invalidateAllMeshes(this.app);
    Texture.invalidateAllTextures(this.app);
    ShaderProgram.invalidateAllShaderPrograms(this.app);
    FrameBuffer.invalidateAllFrameBuffers(this.app);
    SpriteBatch.invalidateAllSpriteBatches(this.app);
  }
  Gdx.app.log("AndroidGraphics", Mesh.getManagedStatus());
  Gdx.app.log("AndroidGraphics", Texture.getManagedStatus());
  Gdx.app.log("AndroidGraphics", ShaderProgram.getManagedStatus());
  Gdx.app.log("AndroidGraphics", FrameBuffer.getManagedStatus());
  Display localDisplay = this.app.getWindowManager().getDefaultDisplay();
  this.width = localDisplay.getWidth();
  this.height = localDisplay.getHeight();
  this.mean = new WindowedMean(5);
  this.lastFrameTime = System.nanoTime();
  paramGL10.glViewport(0, 0, this.width, this.height);
}

@Override
public void write(Kryo kryo, Output output, WindowedMean windowedMean) {
    int size = windowedMean.getWindowSize();
    float[] values = windowedMean.getWindowValues();
    int count = values.length;
    output.writeVarInt(size, true);
    output.writeVarInt(count, true);
    output.writeFloats(values);
}

@Override
public WindowedMean read(Kryo kryo, Input input, Class<WindowedMean> type) {
    int size = input.readVarInt(true);
    int count = input.readVarInt(true);
    float[] values = input.readFloats(count);
    WindowedMean windowedMean = new WindowedMean(size);
    for (int i = 0; i < values.length; i++) {
        windowedMean.addValue(values[i]);
    }
    return windowedMean;
}

@Override
public WindowedMean copy (Kryo kryo, WindowedMean original) {
    WindowedMean windowedMean = new WindowedMean(original.getWindowSize());
    float[] values = original.getWindowValues();
    for (int i = 0; i < values.length; i++) {
        windowedMean.addValue(values[i]);
    }
    return windowedMean;
}

@Override
public void write(Kryo kryo, Output output, FloatCounter floatCounter) {
    kryo.writeObjectOrNull(output, floatCounter.mean, WindowedMean.class);
    output.writeInt(floatCounter.count);
    output.writeFloat(floatCounter.total);
    output.writeFloat(floatCounter.min);
    output.writeFloat(floatCounter.max);
    output.writeFloat(floatCounter.average);
    output.writeFloat(floatCounter.latest);
    output.writeFloat(floatCounter.value);
}

@Override
public void onSurfaceCreated (EGLConfig config) {
   eglContext = ((EGL10)EGLContext.getEGL()).eglGetCurrentContext();
   setupGL();
   logConfig(config);
   updatePpi();

   Mesh.invalidateAllMeshes(app);
   Texture.invalidateAllTextures(app);
   Cubemap.invalidateAllCubemaps(app);
   ShaderProgram.invalidateAllShaderPrograms(app);
   FrameBuffer.invalidateAllFrameBuffers(app);

   logManagedCachesStatus();

   Point outSize = new Point();
   Display display = app.getWindowManager().getDefaultDisplay();
   display.getSize(outSize);
   this.width = outSize.x;
   this.height = outSize.y;
   this.mean = new WindowedMean(5);
   this.lastFrameTime = System.nanoTime();

   gl20.glViewport(0, 0, this.width, this.height);
}