Soft joint limits

[kermado]

I'm seeing odd results in the behavior of joints with soft/spring limits.

I have a body with 1kg mass, limits set to (1, 1), stiffness set to 10 and damping set to 0. There is a D6 joint with the linear x-axis set to eLIMITED. In this case, everything is fine. The body oscillates with a period of 2 seconds.

However, if I make the spring critically damped by setting the damping to 2*sqrt(k*m) = 2*sqrt(10*1) ~= 0.6325, the behavior is not what I expect. The body overshoots. In fact, I can set the damping to a much higher value and the body still overshoots.

It looks like the damping isn't being applied correctly. Is this to be expected, or should I log an issue?

Snippet to reproduce is below:

// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//  * Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//  * Neither the name of NVIDIA CORPORATION nor the names of its
//    contributors may be used to endorse or promote products derived
//    from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Copyright (c) 2008-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.  

// ****************************************************************************
// This snippet illustrates simple use of physx
//
// It creates a number of box stacks on a plane, and if rendering, allows the
// user to create new stacks and fire a ball from the camera position
// ****************************************************************************

#include <ctype.h>
#include <iostream>
#include "PxPhysicsAPI.h"
#include "../../lowlevel/api/include/PxsMaterialManager.h"
#include "../snippetcommon/SnippetPrint.h"
#include "../snippetcommon/SnippetPVD.h"
#include "../snippetutils/SnippetUtils.h"
#include "../snippetrender/SnippetCamera.h"

using namespace physx;

static PxDefaultAllocator		gAllocator;
static PxDefaultErrorCallback	gErrorCallback;
static PxFoundation* gFoundation = NULL;
static PxPhysics* gPhysics = NULL;
static PxDefaultCpuDispatcher* gDispatcher = NULL;
static PxScene* gScene = NULL;
static PxMaterial* gMaterial = NULL;
static PxPvd* gPvd = NULL;
static PxD6Joint* joint = NULL;
static float currentTime = 0;


void initPhysics(bool interactive)
{
	PX_UNUSED(interactive);
	gFoundation = PxCreateFoundation(PX_PHYSICS_VERSION, gAllocator, gErrorCallback);

	gPvd = PxCreatePvd(*gFoundation);
	PxPvdTransport* transport = PxDefaultPvdSocketTransportCreate(PVD_HOST, 5425, 10);
	gPvd->connect(*transport, PxPvdInstrumentationFlag::eALL);

	gPhysics = PxCreatePhysics(PX_PHYSICS_VERSION, *gFoundation, PxTolerancesScale(), true, gPvd);

	PxSceneDesc sceneDesc(gPhysics->getTolerancesScale());
	sceneDesc.gravity = PxVec3(0.0f, 0.0f, 0.0f);
	gDispatcher = PxDefaultCpuDispatcherCreate(0);
	sceneDesc.cpuDispatcher = gDispatcher;
	sceneDesc.filterShader = PxDefaultSimulationFilterShader;
	sceneDesc.solverType = PxSolverType::ePGS;

	gScene = gPhysics->createScene(sceneDesc);

	gMaterial = gPhysics->createMaterial(0.5f, 0.5f, 0.6f);

	PxRigidDynamic* horizontal = gPhysics->createRigidDynamic(PxTransform(PxVec3(0.0, 2.0, 0.0)));
	horizontal->attachShape(*gPhysics->createShape(PxBoxGeometry(PxVec3(1, 1, 1)), *gMaterial, true));
	horizontal->setSolverIterationCounts(128, 8);
	horizontal->setLinearDamping(0.0);
	horizontal->setAngularDamping(0.0);
	horizontal->setSleepThreshold(0);
	physx::PxRigidBodyExt::setMassAndUpdateInertia(*horizontal, 1.0);

	joint = physx::PxD6JointCreate(*gPhysics, horizontal, PxTransform(PxIdentity), nullptr, horizontal->getGlobalPose());
	joint->setMotion(PxD6Axis::eX, PxD6Motion::eLIMITED);
	joint->setLinearLimit(physx::PxD6Axis::eX, physx::PxJointLinearLimitPair(1.0, 1.0, physx::PxSpring(10.0, 6.325)));

	gScene->addActor(*horizontal);
}

void stepPhysics(bool /*interactive*/)
{
	float dt = 1.0f / 100.0f;

	std::cout << currentTime << ": " << joint->getRelativeTransform().p.x << ", " << joint->getRelativeLinearVelocity().x << std::endl;
	
	gScene->simulate(dt);
	gScene->fetchResults(true);
	currentTime += dt;
}

void cleanupPhysics(bool /*interactive*/)
{
	PX_RELEASE(gScene);
	PX_RELEASE(gDispatcher);
	PX_RELEASE(gPhysics);
	if (gPvd)
	{
		PxPvdTransport* transport = gPvd->getTransport();
		gPvd->release();	gPvd = NULL;
		PX_RELEASE(transport);
	}
	PX_RELEASE(gFoundation);

	printf("SnippetHelloWorld done.\n");
}

void keyPress(unsigned char key, const PxTransform& camera)
{
	PX_UNUSED(key);
	PX_UNUSED(camera);
}

int snippetMain(int, const char* const*)
{
#ifdef RENDER_SNIPPET
	extern void renderLoop();
	renderLoop();
#else
	static const PxU32 frameCount = 100;
	initPhysics(false);
	for (PxU32 i = 0; i < frameCount; i++)
		stepPhysics(false);
	cleanupPhysics(false);
#endif

	return 0;
}

[vreutskyy]

Hi @kermado
Thanks for the detailed report. Will check it.