Java Bits类代码示例

import com.badlogic.gdx.utils.Bits; //导入依赖的package包/类
/** @return Whether the entity matches the family requirements or not */
public boolean matches (Entity entity) {
	Bits entityComponentBits = entity.getComponentBits();

	if (!entityComponentBits.containsAll(all)) {
		return false;
	}

	if (!one.isEmpty() && !one.intersects(entityComponentBits)) {
		return false;
	}

	if (!exclude.isEmpty() && exclude.intersects(entityComponentBits)) {
		return false;
	}

	return true;
}
 

import com.badlogic.gdx.utils.Bits; //导入依赖的package包/类
public void removeEntityListener (EntityListener listener) {
	for (int i = 0; i < entityListeners.size; i++) {
		EntityListenerData entityListenerData = entityListeners.get(i);
		if (entityListenerData.listener == listener) {
			// Shift down bitmasks by one step
			for (Bits mask : entityListenerMasks.values()) {
				for (int k = i, n = mask.length(); k < n; k++) {
					if (mask.get(k + 1)) {
						mask.set(k);
					} else {
						mask.clear(k);
					}
				}
			}

			entityListeners.removeIndex(i--);
		}
	}
}
 

import com.badlogic.gdx.utils.Bits; //导入依赖的package包/类
private ImmutableArray<Entity> registerFamily(Family family) {
	ImmutableArray<Entity> entitiesInFamily = immutableFamilies.get(family);

	if (entitiesInFamily == null) {
		Array<Entity> familyEntities = new Array<Entity>(false, 16);
		entitiesInFamily = new ImmutableArray<Entity>(familyEntities);
		families.put(family, familyEntities);
		immutableFamilies.put(family, entitiesInFamily);
		entityListenerMasks.put(family, new Bits());

		for (Entity entity : entities){
			updateFamilyMembership(entity);
		}
	}

	return entitiesInFamily;
}
 

import com.badlogic.gdx.utils.Bits; //导入依赖的package包/类
private int getScore(Bits state, Bits tags) {
	if (!state.containsAll(tags)) {
		return Integer.MIN_VALUE;
	}
	
	tmp.clear();
	tmp.or(state);
	tmp.and(tags);
	
	int score = 0;
	int index = 0;
	
	while ((index = tmp.nextSetBit(index)) > -1) {
		score++;
		index++;
	}
	
	return score;
}
 

import com.badlogic.gdx.utils.Bits; //导入依赖的package包/类
public Entity rayTest(Ray ray, Vector3 hitPointWorld, short belongsToFlag, short collidesWithFlag,
					  float rayDistance, Bits layers) {
	rayFrom.set(ray.origin);
	rayTo.set(ray.direction).scl(rayDistance).add(rayFrom);
	callback.setCollisionObject(null);
	callback.setClosestHitFraction(1f);
	callback.setRay(ray, rayDistance);
	callback.setLayers(layers);

	callback.setCollisionFilterMask(belongsToFlag);
	callback.setCollisionFilterGroup(collidesWithFlag);

	dynamicsWorld.rayTest(rayFrom, rayTo, callback);

	if (callback.hasHit()) {
		if (hitPointWorld != null) {
			callback.getHitPointWorld(hitPointWorld);
		}
		long entityId = callback.getCollisionObject().getUserPointer();
		return getEntity(entityId);
	}
	return null;
}
 

import com.badlogic.gdx.utils.Bits; //导入依赖的package包/类
/**
 * Get the triangle which this ray intersects. Returns null if no triangle is intersected.
 *
 * @param ray
 * @param distance
 * @param allowedMeshParts
 * @return
 */
public Triangle rayTest(Ray ray, float distance, Bits allowedMeshParts) {
	Triangle hitTriangle = null;

	tmpRayTestRayFrom.set(ray.origin);
	tmpRayTestRayTo.set(ray.direction).scl(distance).add(tmpRayTestRayFrom);
	raycastCallback.setHitFraction(1);
	raycastCallback.clearReport();
	raycastCallback.setFrom(tmpRayTestRayFrom);
	raycastCallback.setTo(tmpRayTestRayTo);
	raycastCallback.setAllowedMeshPartIndices(allowedMeshParts);
	collisionShape.performRaycast(raycastCallback, tmpRayTestRayFrom, tmpRayTestRayTo);

	if (raycastCallback.triangleIndex != -1) {
		hitTriangle = graph.getTriangleFromMeshPart(raycastCallback.partId, raycastCallback.triangleIndex);
	}
	return hitTriangle;
}
 

import com.badlogic.gdx.utils.Bits; //导入依赖的package包/类
/**
 * Make a ray test at this point, using a ray spanning from far up in the sky, to far down in the ground,
 * along the up axis.
 *
 * @param testPoint        The test point
 * @param out              The point of intersection between ray and triangle
 * @param allowedMeshParts Which mesh parts to test. Null if all meshparts should be tested.
 * @return The triangle, or null if ray did not hit any triangles.
 */
public Triangle verticalRayTest(Vector3 testPoint, Vector3 out, Bits allowedMeshParts) {
	tmpRayVerticalRayTest.set(
			tmpVerticalRayTest1.set(Constants.V3_UP).scl(500).add(testPoint),
			tmpVerticalRayTest2.set(Constants.V3_DOWN));
	Triangle hitTri = rayTest(tmpRayVerticalRayTest, 1000, allowedMeshParts);
	if (hitTri == null) {
		// TODO: Perhaps this should be Nan?
		out.set(Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY);
		return null;
	} else {

		Intersector.intersectRayTriangle(tmpRayVerticalRayTest, hitTri.a, hitTri.b, hitTri.c, out);
		return hitTri;
	}
}
 

import com.badlogic.gdx.utils.Bits; //导入依赖的package包/类
/**
 * @return Whether the entity matches the family requirements or not
 */
public boolean matches(Entity entity) {
    Bits entityComponentBits = entity.getComponentBits();

    if (entityComponentBits.isEmpty())
        return false;

    for (int i = all.nextSetBit(0); i >= 0; i = all.nextSetBit(i + 1)) {
        if (!entityComponentBits.get(i))
            return false;
    }

    if (!one.isEmpty() && !one.intersects(entityComponentBits)) {
        return false;
    }

    if (!exclude.isEmpty() && exclude.intersects(entityComponentBits)) {
        return false;
    }

    return true;
}
 

import com.badlogic.gdx.utils.Bits; //导入依赖的package包/类
/**
 * @param componentTypes list of {@link Component} classes
 * @return Bits representing the collection of components for quick comparison and matching. See
 *         {@link Family#getFor(Bits, Bits, Bits)}.
 */
public static Bits getBitsFor (Class<? extends Component>... componentTypes) {
	Bits bits = new Bits();

	int typesLength = componentTypes.length;
	for (int i = 0; i < typesLength; i++) {
		bits.set(ComponentType.getIndexFor(componentTypes[i]));
	}

	return bits;
}
 

import com.badlogic.gdx.utils.Bits; //导入依赖的package包/类
/** Private constructor, use static method Family.getFamilyFor() */
private Family (Bits all, Bits any, Bits exclude) {
	this.all = all;
	this.one = any;
	this.exclude = exclude;
	this.index = familyIndex++;
}
 

import com.badlogic.gdx.utils.Bits; //导入依赖的package包/类
private static String getFamilyHash (Bits all, Bits one, Bits exclude) {
	StringBuilder stringBuilder = new StringBuilder();
	if (!all.isEmpty()) {
		stringBuilder.append("{all:").append(getBitsString(all)).append("}");
	}
	if (!one.isEmpty()) {
		stringBuilder.append("{one:").append(getBitsString(one)).append("}");
	}
	if (!exclude.isEmpty()) {
		stringBuilder.append("{exclude:").append(getBitsString(exclude)).append("}");
	}
	return stringBuilder.toString();
}
 

import com.badlogic.gdx.utils.Bits; //导入依赖的package包/类
private static String getBitsString (Bits bits) {
	StringBuilder stringBuilder = new StringBuilder();

	int numBits = bits.length();
	for (int i = 0; i < numBits; ++i) {
		stringBuilder.append(bits.get(i) ? "1" : "0");
	}

	return stringBuilder.toString();
}
 

import com.badlogic.gdx.utils.Bits; //导入依赖的package包/类
/** Creates an empty Entity. */
public Entity () {
	components = new Bag<Component>();
	componentsArray = new Array<Component>(false, 16);
	immutableComponentsArray = new ImmutableArray<Component>(componentsArray);
	componentBits = new Bits();
	familyBits = new Bits();
	flags = 0;

	componentAdded = new Signal<Entity>();
	componentRemoved = new Signal<Entity>();
}
 

import com.badlogic.gdx.utils.Bits; //导入依赖的package包/类
public void addEntityListener (Family family, int priority, EntityListener listener) {
	registerFamily(family);

	int insertionIndex = 0;
	while (insertionIndex < entityListeners.size) {
		if (entityListeners.get(insertionIndex).priority <= priority) {
			insertionIndex++;
		} else {
			break;
		}
	}

	// Shift up bitmasks by one step
	for (Bits mask : entityListenerMasks.values()) {
		for (int k = mask.length(); k > insertionIndex; k--) {
			if (mask.get(k - 1)) {
				mask.set(k);
			} else {
				mask.clear(k);
			}
		}
		mask.clear(insertionIndex);
	}

	entityListenerMasks.get(family).set(insertionIndex);

	EntityListenerData entityListenerData = new EntityListenerData();
	entityListenerData.listener = listener;
	entityListenerData.priority = priority;
	entityListeners.insert(insertionIndex, entityListenerData);
}
 

import com.badlogic.gdx.utils.Bits; //导入依赖的package包/类
@Test
public void addAndRemoveComponent () {
	Entity entity = new Entity();

	entity.add(new ComponentA());

	assertEquals(1, entity.getComponents().size());

	Bits componentBits = entity.getComponentBits();
	int componentAIndex = ComponentType.getIndexFor(ComponentA.class);

	for (int i = 0; i < componentBits.length(); ++i) {
		assertEquals(i == componentAIndex, componentBits.get(i));
	}

	assertNotNull(am.get(entity));
	assertNull(bm.get(entity));
	assertTrue(am.has(entity));
	assertFalse(bm.has(entity));

	entity.remove(ComponentA.class);

	assertEquals(0, entity.getComponents().size());

	for (int i = 0; i < componentBits.length(); ++i) {
		assertFalse(componentBits.get(i));
	}

	assertNull(am.get(entity));
	assertNull(bm.get(entity));
	assertFalse(am.has(entity));
	assertFalse(bm.has(entity));
}