How to use

get

method

in

com.jme3.util.IntMap

public OggPage getOggPage(int index) throws IOException {
  return oggPages.get(index);
}

public int getKerning(int second){
  Integer i = kerning.get(second);
  if (i == null)
    return 0;
  else
    return i.intValue();
}

private void unRegisterListener(int sensorType) {
  SensorData sensorData = sensors.get(sensorType);
  if (sensorData != null) {
    if (sensorData.sensor != null) {
      sensorManager.unregisterListener(this, sensorData.sensor);
    }
    sensorData.enabled = false;
    sensorData.haveData = false;
    logger.log(Level.FINE, "SensorType: {0} deactivated, active: {1}",
        new Object[]{sensorType, sensorData.enabled});
  }
}

/**
 * Get the {@link VertexBuffer} stored on this mesh with the given
 * type.
 *
 * @param type The type of VertexBuffer
 * @return the VertexBuffer data, or null if not set
 */
public VertexBuffer getBuffer(Type type){
  return buffers.get(type.ordinal());
}

public BitmapCharacter getCharacter(int index, int style){
  IntMap<BitmapCharacter> map = getCharacterSet(style);
  return map.get(index);
}

private boolean registerListener(int sensorType) {
  SensorData sensorData = sensors.get(sensorType);
  if (sensorData != null) {
    if (sensorData.enabled) {
      logger.log(Level.FINE, "Sensor Already Active: SensorType: {0}, active: {1}",
          new Object[]{sensorType, sensorData.enabled});
      return true;
    }
    sensorData.haveData = false;
    if (sensorData.sensor != null) {
      if (sensorManager.registerListener(this, sensorData.sensor, sensorData.androidSensorSpeed)) {
        sensorData.enabled = true;
        logger.log(Level.FINE, "SensorType: {0}, actived: {1}",
            new Object[]{sensorType, sensorData.enabled});
        return true;
      } else {
        sensorData.enabled = false;
        logger.log(Level.FINE, "Sensor Type {0} activation failed.", sensorType);
      }
    }
  }
  return false;
}

/**
 * Deletes a mapping from receiving trigger events.
 *
 * <p>
 * The given mapping will no longer be assigned to receive trigger
 * events.
 *
 * @param mappingName The mapping name to unregister.
 *
 * @see InputManager#addMapping(java.lang.String, com.jme3.input.controls.Trigger[])
 */
public void deleteMapping(String mappingName) {
  Mapping mapping = mappings.remove(mappingName);
  if (mapping == null) {
    //throw new IllegalArgumentException("Cannot find mapping: " + mappingName);
    logger.log(Level.WARNING, "Cannot find mapping to be removed, skipping: {0}", mappingName);
    return;
  }
  ArrayList<Integer> triggers = mapping.triggers;
  for (int i = triggers.size() - 1; i >= 0; i--) {
    int hash = triggers.get(i);
    ArrayList<Mapping> maps = bindings.get(hash);
    maps.remove(mapping);
  }
}

private void printEnum(int value) {
  String enumName = constMap.get(value);
  if (enumName != null) {
    if (enumName.startsWith("GL_")) {
      enumName = enumName.substring(3);
    }
    if (enumName.endsWith("_EXT") || enumName.endsWith("_ARB")) {
      enumName = enumName.substring(0, enumName.length() - 4);
    }
    printStyle(ANSI_GREEN, enumName);
  } else {
    printStyle(ANSI_GREEN, "ENUM_" + Integer.toHexString(value));
  }
}

private void invokeActions(int hash, boolean pressed) {
  ArrayList<Mapping> maps = bindings.get(hash);
  if (maps == null) {
    return;
  }
  int size = maps.size();
  for (int i = size - 1; i >= 0; i--) {
    Mapping mapping = maps.get(i);
    ArrayList<InputListener> listeners = mapping.listeners;
    int listenerSize = listeners.size();
    for (int j = listenerSize - 1; j >= 0; j--) {
      InputListener listener = listeners.get(j);
      if (listener instanceof ActionListener) {
        ((ActionListener) listener).onAction(mapping.name, pressed, frameTPF);
      }
    }
  }
}

/**
 * Deletes a specific trigger registered to a mapping.
 *
 * <p>
 * The given mapping will no longer receive events raised by the
 * trigger.
 *
 * @param mappingName The mapping name to cease receiving events from the
 * trigger.
 * @param trigger The trigger to no longer invoke events on the mapping.
 */
public void deleteTrigger(String mappingName, Trigger trigger) {
  Mapping mapping = mappings.get(mappingName);
  if (mapping == null) {
    throw new IllegalArgumentException("Cannot find mapping: " + mappingName);
  }
  ArrayList<Mapping> maps = bindings.get(trigger.triggerHashCode());
  maps.remove(mapping);
}

private void invokeAnalogs(int hash, float value, boolean isAxis) {
  ArrayList<Mapping> maps = bindings.get(hash);
  if (maps == null) {
    return;
  }
  if (!isAxis) {
    value *= frameTPF;
  }
  int size = maps.size();
  for (int i = size - 1; i >= 0; i--) {
    Mapping mapping = maps.get(i);
    ArrayList<InputListener> listeners = mapping.listeners;
    int listenerSize = listeners.size();
    for (int j = listenerSize - 1; j >= 0; j--) {
      InputListener listener = listeners.get(j);
      if (listener instanceof AnalogListener) {
        // NOTE: multiply by TPF for any button bindings
        ((AnalogListener) listener).onAnalog(mapping.name, value, frameTPF);
      }
    }
  }
}

/**
 * Dispatches touch events to touch listeners
 * @param evt The touch event to be dispatched to all onTouch listeners
 */
public void onTouchEventQueued(TouchEvent evt) {
  ArrayList<Mapping> maps = bindings.get(TouchTrigger.touchHash(evt.getKeyCode()));
  if (maps == null) {
    return;
  }
  int size = maps.size();
  for (int i = size - 1; i >= 0; i--) {
    Mapping mapping = maps.get(i);
    ArrayList<InputListener> listeners = mapping.listeners;
    int listenerSize = listeners.size();
    for (int j = listenerSize - 1; j >= 0; j--) {
      InputListener listener = listeners.get(j);
      if (listener instanceof TouchListener) {
        ((TouchListener) listener).onTouch(mapping.name, evt, frameTPF);
      }
    }
  }
}

@Override
public void onAccuracyChanged(Sensor sensor, int i) {
  int sensorType = sensor.getType();
  SensorData sensorData = sensors.get(sensorType);
  if (sensorData != null) {
    logger.log(Level.FINE, "onAccuracyChanged for {0}: accuracy: {1}",
        new Object[]{sensor.getName(), i});
    logger.log(Level.FINE, "MaxRange: {0}, Resolution: {1}",
        new Object[]{sensor.getMaximumRange(), sensor.getResolution()});
    sensorData.sensorAccuracy = i;
  }
}

private IntMap<BitmapCharacter> getCharacterSet(int style) {
  if (characters.size() == 0) {
    characters.put(style, new IntMap<BitmapCharacter>());
  }
  return characters.get(style);
}

private SkinBuffers getSkinBuffers(String bufferType) {
  int bufIndex = getIndex(bufferType);
  SkinBuffers buffs = skinBuffers.get(bufIndex);
  if (buffs == null) {
    buffs = new SkinBuffers();
    skinBuffers.put(bufIndex, buffs);
  }
  return buffs;
}

private SensorData initSensor(int sensorType) {
  boolean success = false;
  SensorData sensorData = sensors.get(sensorType);
  if (sensorData != null) {
    unRegisterListener(sensorType);
  } else {
    sensorData = new SensorData(sensorType, null);
    sensors.put(sensorType, sensorData);
  }
  sensorData.androidSensorType = sensorType;
  sensorData.sensor = sensorManager.getDefaultSensor(sensorType);
  if (sensorData.sensor != null) {
    logger.log(Level.FINE, "Sensor Type {0} found.", sensorType);
    success = registerListener(sensorType);
  } else {
    logger.log(Level.FINE, "Sensor Type {0} not found.", sensorType);
  }
  if (success) {
    return sensorData;
  } else {
    return null;
  }
}

private void invokeAnalogsAndActions(int hash, float value, float effectiveDeadZone, boolean applyTpf) {
  if (value < effectiveDeadZone) {
    invokeAnalogs(hash, value, !applyTpf);
    return;
  }
  ArrayList<Mapping> maps = bindings.get(hash);
  if (maps == null) {
    return;
  }
  boolean valueChanged = !axisValues.containsKey(hash);
  if (applyTpf) {
    value *= frameTPF;
  }
  int size = maps.size();
  for (int i = size - 1; i >= 0; i--) {
    Mapping mapping = maps.get(i);
    ArrayList<InputListener> listeners = mapping.listeners;
    int listenerSize = listeners.size();
    for (int j = listenerSize - 1; j >= 0; j--) {
      InputListener listener = listeners.get(j);
      if (listener instanceof ActionListener && valueChanged) {
        ((ActionListener) listener).onAction(mapping.name, true, frameTPF);
      }
      if (listener instanceof AnalogListener) {
        ((AnalogListener) listener).onAnalog(mapping.name, value, frameTPF);
      }
    }
  }
}

public Attribute getAttribute(VertexBuffer.Type attribType){
  int ordinal = attribType.ordinal();
  Attribute attrib = attribs.get(ordinal);
  if (attrib == null){
    attrib = new Attribute();
    attrib.name = attribType.name();
    attribs.put(ordinal, attrib);
  }
  return attrib;
}

private void startLodFaceList(String submeshindex, String numfaces) {
  int index = Integer.parseInt(submeshindex);
  mesh = geoms.get(index).getMesh();
  int faceCount = Integer.parseInt(numfaces);
  VertexBuffer originalIndexBuffer = mesh.getBuffer(Type.Index);
  vb = new VertexBuffer(VertexBuffer.Type.Index);
  if (originalIndexBuffer.getFormat() == Format.UnsignedInt) {
    // LOD buffer should also be integer
    ib = BufferUtils.createIntBuffer(faceCount * 3);
    sb = null;
    vb.setupData(Usage.Static, 3, Format.UnsignedInt, ib);
  } else {
    sb = BufferUtils.createShortBuffer(faceCount * 3);
    ib = null;
    vb.setupData(Usage.Static, 3, Format.UnsignedShort, sb);
  }
  List<VertexBuffer> levels = lodLevels.get(index);
  if (levels == null) {
    // Create the LOD levels list
    levels = new ArrayList<VertexBuffer>();
    // Add the first LOD level (always the original index buffer)
    levels.add(originalIndexBuffer);
    lodLevels.put(index, levels);
  }
  levels.add(vb);
}

/**
 * Creates a {@link VertexBuffer} for the mesh or modifies
 * the existing one per the parameters given.
 *
 * @param type The type of the buffer
 * @param components Number of components
 * @param format Data format
 * @param buf The buffer data
 *
 * @throws UnsupportedOperationException If the buffer already set is
 * incompatible with the parameters given.
 */
public void setBuffer(Type type, int components, Format format, Buffer buf){
  VertexBuffer vb = buffers.get(type.ordinal());
  if (vb == null){
    vb = new VertexBuffer(type);
    vb.setupData(Usage.Dynamic, components, format, buf);
    setBuffer(vb);
  }else{
    if (vb.getNumComponents() != components || vb.getFormat() != format){
      throw new UnsupportedOperationException("The buffer already set "
          + "is incompatible with the given parameters");
    }
    vb.updateData(buf);
    updateCounts();
  }
}