Java BulletGlobals.SIMD_EPSILON属性代码示例

public void setOptimizedBvh (OptimizedBvh bvh, Vector3 scaling) {
	assert (this.bvh == null);
	assert (!ownsBvh);

	this.bvh = bvh;
	ownsBvh = false;

	Stack stack = Stack.enter();
	// update the scaling without rebuilding the bvh
	Vector3 tmp = stack.allocVector3();
	tmp.set(getLocalScaling(stack.allocVector3())).sub(scaling);

	if (tmp.len2() > BulletGlobals.SIMD_EPSILON) {
		super.setLocalScaling(scaling);
	}
	stack.leave();
}
 

@Override
public Vector3 localGetSupportingVertex (Vector3 vec, Vector3 out) {
	Vector3 supVertex = out;
	localGetSupportingVertexWithoutMargin(vec, supVertex);

	if (getMargin() != 0f) {
		Stack stack = Stack.enter();
		Vector3 vecnorm = stack.alloc(vec);
		if (vecnorm.len2() < (BulletGlobals.SIMD_EPSILON * BulletGlobals.SIMD_EPSILON)) {
			vecnorm.set(-1f, -1f, -1f);
		}
		vecnorm.nor();
		vecnorm.scl(getMargin());
		supVertex.add(vecnorm);
		stack.leave();
	}
	return out;
}
 

@Override
public void setLocalScaling(Vector3f scaling) {
	Vector3f tmp = Stack.alloc(Vector3f.class);
	tmp.sub(getLocalScaling(Stack.alloc(Vector3f.class)), scaling);

	if (tmp.lengthSquared() > BulletGlobals.SIMD_EPSILON) {
		super.setLocalScaling(scaling);
		/*
		if (ownsBvh)
		{
		m_bvh->~btOptimizedBvh();
		btAlignedFree(m_bvh);
		}
		*/
		///m_localAabbMin/m_localAabbMax is already re-calculated in btTriangleMeshShape. We could just scale aabb, but this needs some more work
		bvh = new OptimizedBvh();
		// rebuild the bvh...
		bvh.build(meshInterface, useQuantizedAabbCompression, localAabbMin, localAabbMax);
		ownsBvh = true;
	}
}
 

@Override
public void setLocalScaling(Vector3f scaling) {
	Vector3f tmp = Stack.alloc(Vector3f.class);
	tmp.sub(getLocalScaling(Stack.alloc(Vector3f.class)), scaling);

	if (tmp.lengthSquared() > BulletGlobals.SIMD_EPSILON) {
		super.setLocalScaling(scaling);
		/*
		if (ownsBvh)
		{
		m_bvh->~btOptimizedBvh();
		btAlignedFree(m_bvh);
		}
		*/
		///m_localAabbMin/m_localAabbMax is already re-calculated in btTriangleMeshShape. We could just scale aabb, but this needs some more work
		bvh = new OptimizedBvh();
		// rebuild the bvh...
		bvh.build(meshInterface, useQuantizedAabbCompression, localAabbMin, localAabbMax);

	}
}
 

@ReceiveEvent(components = {TriggerComponent.class, LocationComponent.class})
public void updateTrigger(ChangedComponentEvent event, EntityRef entity) {
    LocationComponent location = entity.getComponent(LocationComponent.class);
    PairCachingGhostObject triggerObj = entityTriggers.get(entity);

    if (triggerObj != null) {
        float scale = location.getWorldScale();
        if (Math.abs(triggerObj.getCollisionShape().getLocalScaling(new Vector3f()).x - scale) > BulletGlobals.SIMD_EPSILON) {
            physics.removeCollider(triggerObj);
            createTrigger(entity);
        } else {
            triggerObj.setWorldTransform(new Transform(new Matrix4f(location.getWorldRotation(), location.getWorldPosition(), 1.0f)));
        }
    }

    // TODO: update if detectGroups changed
}
 

@ReceiveEvent(components = {RigidBodyComponent.class, LocationComponent.class})
public void updateRigidBody(ChangedComponentEvent event, EntityRef entity) {
    LocationComponent location = entity.getComponent(LocationComponent.class);
    RigidBody rigidBody = entityRigidBodies.get(entity);

    if (rigidBody != null) {
        float scale = location.getWorldScale();
        if (Math.abs(rigidBody.getCollisionShape().getLocalScaling(new Vector3f()).x - scale) > BulletGlobals.SIMD_EPSILON) {
            physics.removeRigidBody(rigidBody);
            createRigidBody(entity);
        }

        updateKinematicSettings(entity.getComponent(RigidBodyComponent.class), rigidBody);
    }

    // TODO: update if mass or collision groups change
}
 

private Vector3f extractResidualMovement(Vector3f hitNormal, Vector3f direction, float normalMag) {
    float movementLength = direction.length();
    if (movementLength > BulletGlobals.SIMD_EPSILON) {
        direction.normalize();

        Vector3f reflectDir = Vector3fUtil.reflect(direction, hitNormal, new Vector3f());
        reflectDir.normalize();

        Vector3f perpindicularDir = Vector3fUtil.getPerpendicularComponent(reflectDir, hitNormal, new Vector3f());


        if (normalMag != 0.0f) {
            Vector3f perpComponent = new Vector3f();
            perpComponent.scale(normalMag * movementLength, perpindicularDir);
            direction.set(perpComponent);
        }
    }
    return direction;
}
 

private static Vector3 getNormalizedVector (Vector3 v, Vector3 out) {
	out.set(v);
	out.nor();
	if (out.len() < BulletGlobals.SIMD_EPSILON) {
		out.set(0, 0, 0);
	}
	return out;
}
 

protected void updateTargetPositionBasedOnCollision (Vector3 hitNormal, float tangentMag, float normalMag) {
	Stack stack = Stack.enter();
	Vector3 movementDirection = stack.allocVector3();
	movementDirection.set(targetPosition).sub(currentPosition);
	float movementLength = movementDirection.len();
	if (movementLength > BulletGlobals.SIMD_EPSILON) {
		movementDirection.nor();

		Vector3 reflectDir = computeReflectionDirection(movementDirection, hitNormal, stack.allocVector3());
		reflectDir.nor();

		Vector3 parallelDir = parallelComponent(reflectDir, hitNormal, stack.allocVector3());
		Vector3 perpindicularDir = perpindicularComponent(reflectDir, hitNormal, stack.allocVector3());

		targetPosition.set(currentPosition);
		if (false) // tangentMag != 0.0)
		{
			Vector3 parComponent = stack.allocVector3();
			parComponent.set(parallelDir).scl(tangentMag * movementLength);
			// printf("parComponent=%f,%f,%f\n",parComponent[0],parComponent[1],parComponent[2]);
			targetPosition.add(parComponent);
		}

		if (normalMag != 0.0f) {
			Vector3 perpComponent = stack.allocVector3();
			perpComponent.set(perpindicularDir).scl(normalMag * movementLength);
			// printf("perpComponent=%f,%f,%f\n",perpComponent[0],perpComponent[1],perpComponent[2]);
			targetPosition.add(perpComponent);
		}
	} else {
		// printf("movementLength don't normalize a zero vector\n");
	}
	stack.leave();
}
 

/** This function calcs the distance from a 3D plane. */
public static void plane_clip_polygon_collect (Vector3 point0, Vector3 point1, float dist0, float dist1,
	ObjectArrayList<Vector3> clipped, int[] clipped_count) {
	boolean _prevclassif = (dist0 > BulletGlobals.SIMD_EPSILON);
	boolean _classif = (dist1 > BulletGlobals.SIMD_EPSILON);
	if (_classif != _prevclassif) {
		float blendfactor = -dist0 / (dist1 - dist0);
		vec_blend(clipped.getQuick(clipped_count[0]), point0, point1, blendfactor);
		clipped_count[0]++;
	}
	if (!_classif) {
		clipped.getQuick(clipped_count[0]).set(point1);
		clipped_count[0]++;
	}
}
 

/** Clips a polygon by a plane.
 * 
 * @return The count of the clipped counts */
public static int plane_clip_polygon (Quaternion plane, ObjectArrayList<Vector3> polygon_points, int polygon_point_count,
	ObjectArrayList<Vector3> clipped) {
	ArrayPool<int[]> intArrays = ArrayPool.get(int.class);

	int[] clipped_count = intArrays.getFixed(1);
	clipped_count[0] = 0;

	// clip first point
	float firstdist = distance_point_plane(plane, polygon_points.getQuick(0));
	if (!(firstdist > BulletGlobals.SIMD_EPSILON)) {
		clipped.getQuick(clipped_count[0]).set(polygon_points.getQuick(0));
		clipped_count[0]++;
	}

	float olddist = firstdist;
	for (int i = 1; i < polygon_point_count; i++) {
		float dist = distance_point_plane(plane, polygon_points.getQuick(i));

		plane_clip_polygon_collect(polygon_points.getQuick(i - 1), polygon_points.getQuick(i), olddist, dist, clipped,
			clipped_count);

		olddist = dist;
	}

	// RETURN TO FIRST point

	plane_clip_polygon_collect(polygon_points.getQuick(polygon_point_count - 1), polygon_points.getQuick(0), olddist, firstdist,
		clipped, clipped_count);

	int ret = clipped_count[0];
	intArrays.release(clipped_count);
	return ret;
}
 

/** Clips a polygon by a plane.
 * 
 * @param clipped must be an array of 16 points.
 * @return the count of the clipped counts */
public static int plane_clip_triangle (Quaternion plane, Vector3 point0, Vector3 point1, Vector3 point2,
	ObjectArrayList<Vector3> clipped) {
	ArrayPool<int[]> intArrays = ArrayPool.get(int.class);

	int[] clipped_count = intArrays.getFixed(1);
	clipped_count[0] = 0;

	// clip first point0
	float firstdist = distance_point_plane(plane, point0);
	if (!(firstdist > BulletGlobals.SIMD_EPSILON)) {
		clipped.getQuick(clipped_count[0]).set(point0);
		clipped_count[0]++;
	}

	// point 1
	float olddist = firstdist;
	float dist = distance_point_plane(plane, point1);

	plane_clip_polygon_collect(point0, point1, olddist, dist, clipped, clipped_count);

	olddist = dist;

	// point 2
	dist = distance_point_plane(plane, point2);

	plane_clip_polygon_collect(point1, point2, olddist, dist, clipped, clipped_count);
	olddist = dist;

	// RETURN TO FIRST point0
	plane_clip_polygon_collect(point2, point0, olddist, firstdist, clipped, clipped_count);

	int ret = clipped_count[0];
	intArrays.release(clipped_count);
	return ret;
}
 

/**
 * Classify points that are closer.
 */
public void merge_points(Quaternion plane, float margin, ObjectArrayList<Vector3> points, int point_count) {
	this.point_count = 0;
	penetration_depth = -1000.0f;

	int[] point_indices = intArrays.getFixed(MAX_TRI_CLIPPING);

	for (int _k = 0; _k < point_count; _k++) {
		float _dist = -ClipPolygon.distance_point_plane(plane, points.getQuick(_k)) + margin;

		if (_dist >= 0.0f) {
			if (_dist > penetration_depth) {
				penetration_depth = _dist;
				point_indices[0] = _k;
				this.point_count = 1;
			}
			else if ((_dist + BulletGlobals.SIMD_EPSILON) >= penetration_depth) {
				point_indices[this.point_count] = _k;
				this.point_count++;
			}
		}
	}

	for (int _k = 0; _k < this.point_count; _k++) {
		this.points[_k].set(points.getQuick(point_indices[_k]));
	}
	
	intArrays.release(point_indices);
}
 

/**
 * Find closest points on segments.
 */
public static void segment_collision(Vector3f vA1, Vector3f vA2, Vector3f vB1, Vector3f vB2, Vector3f vPointA, Vector3f vPointB) {
	Vector3f AD = Stack.alloc(Vector3f.class);
	AD.sub(vA2, vA1);

	Vector3f BD = Stack.alloc(Vector3f.class);
	BD.sub(vB2, vB1);

	Vector3f N = Stack.alloc(Vector3f.class);
	N.cross(AD, BD);
	float[] tp = new float[] { N.lengthSquared() };

	Vector4f _M = Stack.alloc(Vector4f.class);//plane

	if (tp[0] < BulletGlobals.SIMD_EPSILON)//ARE PARALELE
	{
		// project B over A
		boolean invert_b_order = false;
		_M.x = vB1.dot(AD);
		_M.y = vB2.dot(AD);

		if (_M.x > _M.y) {
			invert_b_order = true;
			//BT_SWAP_NUMBERS(_M[0],_M[1]);
			_M.x = _M.x + _M.y;
			_M.y = _M.x - _M.y;
			_M.x = _M.x - _M.y;
		}
		_M.z = vA1.dot(AD);
		_M.w = vA2.dot(AD);
		// mid points
		N.x = (_M.x + _M.y) * 0.5f;
		N.y = (_M.z + _M.w) * 0.5f;

		if (N.x < N.y) {
			if (_M.y < _M.z) {
				vPointB = invert_b_order ? vB1 : vB2;
				vPointA = vA1;
			}
			else if (_M.y < _M.w) {
				vPointB = invert_b_order ? vB1 : vB2;
				closest_point_on_segment(vPointA, vPointB, vA1, vA2);
			}
			else {
				vPointA = vA2;
				closest_point_on_segment(vPointB, vPointA, vB1, vB2);
			}
		}
		else {
			if (_M.w < _M.x) {
				vPointB = invert_b_order ? vB2 : vB1;
				vPointA = vA2;
			}
			else if (_M.w < _M.y) {
				vPointA = vA2;
				closest_point_on_segment(vPointB, vPointA, vB1, vB2);
			}
			else {
				vPointB = invert_b_order ? vB1 : vB2;
				closest_point_on_segment(vPointA, vPointB, vA1, vA2);
			}
		}
		return;
	}

	N.cross(N, BD);
	_M.set(N.x, N.y, N.z, vB1.dot(N));

	// get point A as the plane collision point
	line_plane_collision(_M, AD, vA1, vPointA, tp, 0f, 1f);

	/*Closest point on segment*/
	vPointB.sub(vPointA, vB1);
	tp[0] = vPointB.dot(BD);
	tp[0] /= BD.dot(BD);
	tp[0] = CLAMP(tp[0], 0.0f, 1.0f);

	vPointB.scaleAdd(tp[0], BD, vB1);
}
 

@Override
public Vector3f localGetSupportingVertex(Vector3f vec, Vector3f out) {
	Vector3f supVertex = out;
	localGetSupportingVertexWithoutMargin(vec, supVertex);

	if (getMargin() != 0f) {
		Vector3f vecnorm = Stack.alloc(vec);
		if (vecnorm.lengthSquared() < (BulletGlobals.SIMD_EPSILON * BulletGlobals.SIMD_EPSILON)) {
			vecnorm.set(-1f, -1f, -1f);
		}
		vecnorm.normalize();
		supVertex.scaleAdd(getMargin(), vecnorm, supVertex);
	}
	return out;
}