From c3697b254d123322d19b0d6f476a8dbc1e4f75eb Mon Sep 17 00:00:00 2001 From: stephengold Date: Sat, 6 Jul 2024 21:24:51 -0700 Subject: [PATCH] BodyCreationSettings: add 18 public accessors --- config/checkstyle/checkstyle.xml | 2 +- .../joltjni/BodyCreationSettings.java | 301 +++++++++++++++ ...ephengold_joltjni_BodyCreationSettings.cpp | 348 ++++++++++++++++++ 3 files changed, 650 insertions(+), 1 deletion(-) diff --git a/config/checkstyle/checkstyle.xml b/config/checkstyle/checkstyle.xml index a46a0346..3f9ab8a4 100644 --- a/config/checkstyle/checkstyle.xml +++ b/config/checkstyle/checkstyle.xml @@ -29,7 +29,7 @@ - + diff --git a/src/main/java/com/github/stephengold/joltjni/BodyCreationSettings.java b/src/main/java/com/github/stephengold/joltjni/BodyCreationSettings.java index 7b4e13a1..e75a712a 100644 --- a/src/main/java/com/github/stephengold/joltjni/BodyCreationSettings.java +++ b/src/main/java/com/github/stephengold/joltjni/BodyCreationSettings.java @@ -80,6 +80,186 @@ public BodyCreationSettings(ShapeSettings shapeSettings, RVec3Arg loc, // ************************************************************************* // new methods exposed + /** + * Return the angular damping constant. (native field: mAngularDamping) + * + * @return the constant (in units of 1/second, ≥0, ≤1) + */ + public float getAngularDamping() { + long bodySettingsVa = va(); + float result = getAngularDamping(bodySettingsVa); + + return result; + } + + /** + * Copy the (initial) angular velocity. (native field: mAngularVelocity) + * + * @return a new velocity vector (radians per second in physics-system + * coordinates) + */ + public Vec3 getAngularVelocity() { + long bodySettingsVa = va(); + float vx = getAngularVelocityX(bodySettingsVa); + float vy = getAngularVelocityY(bodySettingsVa); + float vz = getAngularVelocityZ(bodySettingsVa); + Vec3 result = new Vec3(vx, vy, vz); + + return result; + } + + /** + * Return the friction ratio. (native field: mFriction) + * + * @return the ratio (typically ≥0 and ≤1) + */ + public float getFriction() { + long bodySettingsVa = va(); + float result = getFriction(bodySettingsVa); + + return result; + } + + /** + * Return the gravity factor. + * + * @return the factor + */ + public float getGravityFactor() { + long bodySettingsVa = va(); + float result = getGravityFactor(bodySettingsVa); + + return result; + } + + /** + * Return the linear damping constant. (native field: mLinearDamping) + * + * @return the constant (in units of 1/second, ≥0, ≤1) + */ + public float getLinearDamping() { + long bodySettingsVa = va(); + float result = getLinearDamping(bodySettingsVa); + + return result; + } + + /** + * Copy the (initial) linear velocity. (native field: mLinearVelocity) + * + * @return a new velocity vector (meters per second in physics-system + * coordinates) + */ + public Vec3 getLinearVelocity() { + long bodySettingsVa = va(); + float vx = getLinearVelocityX(bodySettingsVa); + float vy = getLinearVelocityY(bodySettingsVa); + float vz = getLinearVelocityZ(bodySettingsVa); + Vec3 result = new Vec3(vx, vy, vz); + + return result; + } + + /** + * Calculate the mass and inertia. + * + * @return a new instance + */ + public MassProperties getMassProperties() { + long bodySettingsVa = va(); + long propertiesVa = getMassProperties(bodySettingsVa); + MassProperties result = new MassProperties(propertiesVa); + + return result; + } + + /** + * Return the motion quality. (native field: mMotionQuality) + * + * @return an enum value (not null) + */ + public EMotionQuality getMotionQuality() { + long bodySettingsVa = va(); + int ordinal = getMotionQuality(bodySettingsVa); + EMotionQuality result = EMotionQuality.values()[ordinal]; + + return result; + } + + /** + * Return the motion type. (native field: mMotionType) + * + * @return an enum value (not null) + */ + public EMotionType getMotionType() { + long bodySettingsVa = va(); + int ordinal = getMotionType(bodySettingsVa); + EMotionType result = EMotionType.values()[ordinal]; + + return result; + } + + /** + * Return the index of the object layer. (native field: mObjectLayer) + * + * @return the index (≥0, <numObjectLayers) + */ + public int getObjectLayer() { + long bodySettingsVa = va(); + int result = getObjectLayer(bodySettingsVa); + + return result; + } + + /** + * Return the (initial) location. (native field: mPosition) + * + * @return a new location vector (in physics-system coordinates) + */ + public RVec3 getPosition() { + long bodySettingsVa = va(); + + double xx = getPositionX(bodySettingsVa); + assert Double.isFinite(xx) : "xx = " + xx; + + double yy = getPositionY(bodySettingsVa); + assert Double.isFinite(yy) : "yy = " + yy; + + double zz = getPositionZ(bodySettingsVa); + assert Double.isFinite(zz) : "zz = " + zz; + + RVec3 result = new RVec3(xx, yy, zz); + return result; + } + + /** + * Return the restitution ratio. (native field: mRestitution) + * + * @return the ratio (typically ≥0 and ≤1) + */ + public float getRestitution() { + long bodySettingsVa = va(); + float result = getRestitution(bodySettingsVa); + return result; + } + + /** + * Copy the (initial) orientation of the body's axes. (native field: + * mRotation) + * + * @return a new rotation quaternion (relative to the physics-system axes) + */ + public Quat getRotation() { + long bodySettingsVa = va(); + float qw = getRotationW(bodySettingsVa); + float qx = getRotationX(bodySettingsVa); + float qy = getRotationY(bodySettingsVa); + float qz = getRotationZ(bodySettingsVa); + Quat result = new Quat(qx, qy, qz, qw); + + return result; + } + /** * Access the shape. * @@ -92,6 +272,29 @@ public Shape getShape() { return result; } + /** + * Alter the angular damping constant. (native field: mAngularDamping) + * + * @param damping the desired value (in units of 1/second, ≥0, ≤1, + * default=0.05) + */ + public void setAngularDamping(float damping) { + long bodySettingsVa = va(); + setAngularDamping(bodySettingsVa, damping); + } + + /** + * Alter the (initial) angular velocity. (native field: mAngularVelocity) + * + * @param omega the desired angular velocity (radians per second in + * physics-system coordinates, not null, unaffected) + */ + public void setAngularVelocity(Vec3Arg omega) { + long bodySettingsVa = va(); + setAngularVelocity(bodySettingsVa, + omega.getX(), omega.getY(), omega.getZ()); + } + /** * Alter the friction ratio. * @@ -112,6 +315,29 @@ public void setGravityFactor(float factor) { setGravityFactor(bodySettingsVa, factor); } + /** + * Alter the linear damping constant. (native field: mLinearDamping) + * + * @param damping the desired value (in units of 1/second, ≥0, ≤1, + * default=0.05) + */ + public void setLinearDamping(float damping) { + long bodySettingsVa = va(); + setLinearDamping(bodySettingsVa, damping); + } + + /** + * Alter the (initial) linear velocity. (native field: mLinearVelocity) + * + * @param velocity the desired velocity (in physics-system coordinates, not + * null, unaffected, default=(0,0,0)) + */ + public void setLinearVelocity(Vec3Arg velocity) { + long bodySettingsVa = va(); + setLinearVelocity(bodySettingsVa, + velocity.getX(), velocity.getY(), velocity.getZ()); + } + /** * Alter the motion quality. * @@ -165,6 +391,22 @@ public void setRestitution(float restitution) { setRestitution(bodySettingsVa, restitution); } + /** + * Alter the (initial) orientation of the body's axes. (native field: + * mRotation) + * + * @param quat the desired rotation (relative to the physics-system axes, + * not null, unaffected, default=(0,0,0,1)) + */ + public void setRotation(Quat quat) { + long bodySettingsVa = va(); + float qw = quat.getW(); + float qx = quat.getX(); + float qy = quat.getY(); + float qz = quat.getZ(); + setRotation(bodySettingsVa, qx, qy, qz, qw); + } + /** * Alter the shape. * @@ -219,13 +461,69 @@ native private static long createBodyCreationSettingsFromShapeSettings( native private static void free(long bodySettingsVa); + native private static float getAngularDamping(long bodySettingsVa); + + native private static float getAngularVelocityX(long bodySettingsVa); + + native private static float getAngularVelocityY(long bodySettingsVa); + + native private static float getAngularVelocityZ(long bodySettingsVa); + + native private static float getFriction(long bodySettingsVa); + + native private static float getGravityFactor(long bodySettingsVa); + + native private static float getLinearDamping(long bodySettingsVa); + + native private static float getLinearVelocityX(long bodySettingsVa); + + native private static float getLinearVelocityY(long bodySettingsVa); + + native private static float getLinearVelocityZ(long bodySettingsVa); + + native private static long getMassProperties(long bodySettingsVa); + + native private static int getMotionQuality(long bodySettingsVa); + + native private static int getMotionType(long bodySettingsVa); + + native private static int getObjectLayer(long bodySettingsVa); + + native private static double getPositionX(long bodySettingsVa); + + native private static double getPositionY(long bodySettingsVa); + + native private static double getPositionZ(long bodySettingsVa); + + native private static float getRestitution(long bodySettingsVa); + + native private static float getRotationW(long bodySettingsVa); + + native private static float getRotationX(long bodySettingsVa); + + native private static float getRotationY(long bodySettingsVa); + + native private static float getRotationZ(long bodySettingsVa); + native private static long getShape(long bodySettingsVa); + native private static void setAngularDamping( + long bodySettingsVa, float damping); + + native private static void setAngularVelocity(long bodySettingsVa, + float wx, float wy, float wz); + native private static void setFriction(long bodySettingsVa, float friction); native private static void setGravityFactor( long bodySettingsVa, float factor); + native private static void setLinearDamping( + long bodySettingsVa, float damping); + + native private static void setLinearVelocity(long bodySettingsVa, + float vx, float vy, float vz); + native private static void setMotionQuality( long bodySettingsVa, int motionQualityOrdinal); @@ -241,6 +539,9 @@ native private static void setPosition( native private static void setRestitution( long bodySettingsVa, float restitution); + native private static void setRotation(long bodySettingsVa, + float qx, float qy, float qz, float qw); + native private static void setShape(long bodySettingsVa, long shapeVa); native private static void setShapeSettings( diff --git a/src/main/native/glue/com_github_stephengold_joltjni_BodyCreationSettings.cpp b/src/main/native/glue/com_github_stephengold_joltjni_BodyCreationSettings.cpp index e7e0dc38..70805b21 100644 --- a/src/main/native/glue/com_github_stephengold_joltjni_BodyCreationSettings.cpp +++ b/src/main/native/glue/com_github_stephengold_joltjni_BodyCreationSettings.cpp @@ -87,6 +87,293 @@ JNIEXPORT void JNICALL Java_com_github_stephengold_joltjni_BodyCreationSettings_ delete pSettings; } +/* + * Class: com_github_stephengold_joltjni_BodyCreationSettings + * Method: getAngularDamping + * Signature: (J)F + */ +JNIEXPORT jfloat JNICALL Java_com_github_stephengold_joltjni_BodyCreationSettings_getAngularDamping + (JNIEnv *, jclass, jlong bodySettingsVa) { + const BodyCreationSettings * const pSettings + = reinterpret_cast (bodySettingsVa); + float result = pSettings->mAngularDamping; + return result; +} + +/* + * Class: com_github_stephengold_joltjni_BodyCreationSettings + * Method: getAngularVelocityX + * Signature: (J)F + */ +JNIEXPORT jfloat JNICALL Java_com_github_stephengold_joltjni_BodyCreationSettings_getAngularVelocityX + (JNIEnv *, jclass, jlong bodySettingsVa) { + const BodyCreationSettings * const pSettings + = reinterpret_cast (bodySettingsVa); + float result = pSettings->mAngularVelocity.GetX(); + return result; +} + +/* + * Class: com_github_stephengold_joltjni_BodyCreationSettings + * Method: getAngularVelocityY + * Signature: (J)F + */ +JNIEXPORT jfloat JNICALL Java_com_github_stephengold_joltjni_BodyCreationSettings_getAngularVelocityY + (JNIEnv *, jclass, jlong bodySettingsVa) { + const BodyCreationSettings * const pSettings + = reinterpret_cast (bodySettingsVa); + float result = pSettings->mAngularVelocity.GetY(); + return result; +} + +/* + * Class: com_github_stephengold_joltjni_BodyCreationSettings + * Method: getAngularVelocityZ + * Signature: (J)F + */ +JNIEXPORT jfloat JNICALL Java_com_github_stephengold_joltjni_BodyCreationSettings_getAngularVelocityZ + (JNIEnv *, jclass, jlong bodySettingsVa) { + const BodyCreationSettings * const pSettings + = reinterpret_cast (bodySettingsVa); + float result = pSettings->mAngularVelocity.GetZ(); + return result; +} + +/* + * Class: com_github_stephengold_joltjni_BodyCreationSettings + * Method: getFriction + * Signature: (J)F + */ +JNIEXPORT jfloat JNICALL Java_com_github_stephengold_joltjni_BodyCreationSettings_getFriction + (JNIEnv *, jclass, jlong bodySettingsVa) { + const BodyCreationSettings * const pSettings + = reinterpret_cast (bodySettingsVa); + float result = pSettings->mFriction; + return result; +} + +/* + * Class: com_github_stephengold_joltjni_BodyCreationSettings + * Method: getGravityFactor + * Signature: (J)F + */ +JNIEXPORT jfloat JNICALL Java_com_github_stephengold_joltjni_BodyCreationSettings_getGravityFactor + (JNIEnv *, jclass, jlong bodySettingsVa) { + const BodyCreationSettings * const pSettings + = reinterpret_cast (bodySettingsVa); + float result = pSettings->mGravityFactor; + return result; +} + +/* + * Class: com_github_stephengold_joltjni_BodyCreationSettings + * Method: getLinearDamping + * Signature: (J)F + */ +JNIEXPORT jfloat JNICALL Java_com_github_stephengold_joltjni_BodyCreationSettings_getLinearDamping + (JNIEnv *, jclass, jlong bodySettingsVa) { + const BodyCreationSettings * const pSettings + = reinterpret_cast (bodySettingsVa); + float result = pSettings->mLinearDamping; + return result; +} + +/* + * Class: com_github_stephengold_joltjni_BodyCreationSettings + * Method: getLinearVelocityX + * Signature: (J)F + */ +JNIEXPORT jfloat JNICALL Java_com_github_stephengold_joltjni_BodyCreationSettings_getLinearVelocityX + (JNIEnv *, jclass, jlong bodySettingsVa) { + const BodyCreationSettings * const pSettings + = reinterpret_cast (bodySettingsVa); + float result = pSettings->mLinearVelocity.GetX(); + return result; +} + +/* + * Class: com_github_stephengold_joltjni_BodyCreationSettings + * Method: getLinearVelocityY + * Signature: (J)F + */ +JNIEXPORT jfloat JNICALL Java_com_github_stephengold_joltjni_BodyCreationSettings_getLinearVelocityY + (JNIEnv *, jclass, jlong bodySettingsVa) { + const BodyCreationSettings * const pSettings + = reinterpret_cast (bodySettingsVa); + float result = pSettings->mLinearVelocity.GetY(); + return result; +} + +/* + * Class: com_github_stephengold_joltjni_BodyCreationSettings + * Method: getLinearVelocityZ + * Signature: (J)F + */ +JNIEXPORT jfloat JNICALL Java_com_github_stephengold_joltjni_BodyCreationSettings_getLinearVelocityZ + (JNIEnv *, jclass, jlong bodySettingsVa) { + const BodyCreationSettings * const pSettings + = reinterpret_cast (bodySettingsVa); + float result = pSettings->mLinearVelocity.GetZ(); + return result; +} + +/* + * Class: com_github_stephengold_joltjni_BodyCreationSettings + * Method: getMassProperties + * Signature: (J)J + */ +JNIEXPORT jlong JNICALL Java_com_github_stephengold_joltjni_BodyCreationSettings_getMassProperties + (JNIEnv *, jclass, jlong bodySettingsVa) { + const BodyCreationSettings * const pSettings + = reinterpret_cast (bodySettingsVa); + MassProperties * const pResult = new MassProperties(); + *pResult = pSettings->GetMassProperties(); + return reinterpret_cast (pResult); +} + +/* + * Class: com_github_stephengold_joltjni_BodyCreationSettings + * Method: getMotionQuality + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_com_github_stephengold_joltjni_BodyCreationSettings_getMotionQuality + (JNIEnv *, jclass, jlong bodySettingsVa) { + const BodyCreationSettings * const pSettings + = reinterpret_cast (bodySettingsVa); + EMotionQuality result = pSettings->mMotionQuality; + return (jint) result; +} + +/* + * Class: com_github_stephengold_joltjni_BodyCreationSettings + * Method: getMotionType + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_com_github_stephengold_joltjni_BodyCreationSettings_getMotionType + (JNIEnv *, jclass, jlong bodySettingsVa) { + const BodyCreationSettings * const pSettings + = reinterpret_cast (bodySettingsVa); + EMotionType result = pSettings->mMotionType; + return (jint) result; +} + +/* + * Class: com_github_stephengold_joltjni_BodyCreationSettings + * Method: getObjectLayer + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_com_github_stephengold_joltjni_BodyCreationSettings_getObjectLayer + (JNIEnv *, jclass, jlong bodySettingsVa) { + const BodyCreationSettings * const pSettings + = reinterpret_cast (bodySettingsVa); + int result = pSettings->mObjectLayer; + return (jint) result; +} + +/* + * Class: com_github_stephengold_joltjni_BodyCreationSettings + * Method: getPositionX + * Signature: (J)D + */ +JNIEXPORT jdouble JNICALL Java_com_github_stephengold_joltjni_BodyCreationSettings_getPositionX + (JNIEnv *, jclass, jlong bodySettingsVa) { + const BodyCreationSettings * const pSettings + = reinterpret_cast (bodySettingsVa); + double result = pSettings->mPosition.GetX(); + return result; +} + +/* + * Class: com_github_stephengold_joltjni_BodyCreationSettings + * Method: getPositionY + * Signature: (J)D + */ +JNIEXPORT jdouble JNICALL Java_com_github_stephengold_joltjni_BodyCreationSettings_getPositionY + (JNIEnv *, jclass, jlong bodySettingsVa) { + const BodyCreationSettings * const pSettings + = reinterpret_cast (bodySettingsVa); + double result = pSettings->mPosition.GetY(); + return result; +} + +/* + * Class: com_github_stephengold_joltjni_BodyCreationSettings + * Method: getPositionZ + * Signature: (J)D + */ +JNIEXPORT jdouble JNICALL Java_com_github_stephengold_joltjni_BodyCreationSettings_getPositionZ + (JNIEnv *, jclass, jlong bodySettingsVa) { + const BodyCreationSettings * const pSettings + = reinterpret_cast (bodySettingsVa); + double result = pSettings->mPosition.GetZ(); + return result; +} + +/* + * Class: com_github_stephengold_joltjni_BodyCreationSettings + * Method: getRestitution + * Signature: (J)F + */ +JNIEXPORT jfloat JNICALL Java_com_github_stephengold_joltjni_BodyCreationSettings_getRestitution + (JNIEnv *, jclass, jlong bodySettingsVa) { + const BodyCreationSettings * const pSettings + = reinterpret_cast (bodySettingsVa); + float result = pSettings->mRestitution; + return result; +} + +/* + * Class: com_github_stephengold_joltjni_BodyCreationSettings + * Method: getRotationW + * Signature: (J)F + */ +JNIEXPORT jfloat JNICALL Java_com_github_stephengold_joltjni_BodyCreationSettings_getRotationW + (JNIEnv *, jclass, jlong bodySettingsVa) { + const BodyCreationSettings * const pSettings + = reinterpret_cast (bodySettingsVa); + double result = pSettings->mRotation.GetW(); + return result; +} + +/* + * Class: com_github_stephengold_joltjni_BodyCreationSettings + * Method: getRotationX + * Signature: (J)F + */ +JNIEXPORT jfloat JNICALL Java_com_github_stephengold_joltjni_BodyCreationSettings_getRotationX + (JNIEnv *, jclass, jlong bodySettingsVa) { + const BodyCreationSettings * const pSettings + = reinterpret_cast (bodySettingsVa); + double result = pSettings->mRotation.GetX(); + return result; +} + +/* + * Class: com_github_stephengold_joltjni_BodyCreationSettings + * Method: getRotationY + * Signature: (J)F + */ +JNIEXPORT jfloat JNICALL Java_com_github_stephengold_joltjni_BodyCreationSettings_getRotationY + (JNIEnv *, jclass, jlong bodySettingsVa) { + const BodyCreationSettings * const pSettings + = reinterpret_cast (bodySettingsVa); + double result = pSettings->mRotation.GetY(); + return result; +} + +/* + * Class: com_github_stephengold_joltjni_BodyCreationSettings + * Method: getRotationZ + * Signature: (J)F + */ +JNIEXPORT jfloat JNICALL Java_com_github_stephengold_joltjni_BodyCreationSettings_getRotationZ + (JNIEnv *, jclass, jlong bodySettingsVa) { + const BodyCreationSettings * const pSettings + = reinterpret_cast (bodySettingsVa); + double result = pSettings->mRotation.GetZ(); + return result; +} + /* * Class: com_github_stephengold_joltjni_BodyCreationSettings * Method: getShape @@ -100,6 +387,30 @@ JNIEXPORT jlong JNICALL Java_com_github_stephengold_joltjni_BodyCreationSettings return reinterpret_cast (pShape); } +/* + * Class: com_github_stephengold_joltjni_BodyCreationSettings + * Method: setAngularDamping + * Signature: (JF)V + */ +JNIEXPORT void JNICALL Java_com_github_stephengold_joltjni_BodyCreationSettings_setAngularDamping + (JNIEnv *, jclass, jlong bodySettingsVa, jfloat damping) { + BodyCreationSettings * const pSettings + = reinterpret_cast (bodySettingsVa); + pSettings->mAngularDamping = damping; +} + +/* + * Class: com_github_stephengold_joltjni_BodyCreationSettings + * Method: setAngularVelocity + * Signature: (JFFF)V + */ +JNIEXPORT void JNICALL Java_com_github_stephengold_joltjni_BodyCreationSettings_setAngularVelocity + (JNIEnv *, jclass, jlong bodySettingsVa, jfloat wx, jfloat wy, jfloat wz) { + BodyCreationSettings * const pSettings + = reinterpret_cast (bodySettingsVa); + pSettings->mAngularVelocity.Set(wx, wy, wz); +} + /* * Class: com_github_stephengold_joltjni_BodyCreationSettings * Method: setFriction @@ -123,6 +434,31 @@ JNIEXPORT void JNICALL Java_com_github_stephengold_joltjni_BodyCreationSettings_ = reinterpret_cast (bodySettingsVa); pSettings->mGravityFactor = factor; } + +/* + * Class: com_github_stephengold_joltjni_BodyCreationSettings + * Method: setLinearDamping + * Signature: (JF)V + */ +JNIEXPORT void JNICALL Java_com_github_stephengold_joltjni_BodyCreationSettings_setLinearDamping + (JNIEnv *, jclass, jlong bodySettingsVa, jfloat damping) { + BodyCreationSettings * const pSettings + = reinterpret_cast (bodySettingsVa); + pSettings->mLinearDamping = damping; +} + +/* + * Class: com_github_stephengold_joltjni_BodyCreationSettings + * Method: setLinearVelocity + * Signature: (JFFF)V + */ +JNIEXPORT void JNICALL Java_com_github_stephengold_joltjni_BodyCreationSettings_setLinearVelocity + (JNIEnv *, jclass, jlong bodySettingsVa, jfloat vx, jfloat vy, jfloat vz) { + BodyCreationSettings * const pSettings + = reinterpret_cast (bodySettingsVa); + pSettings->mLinearVelocity.Set(vx, vy, vz); +} + /* * Class: com_github_stephengold_joltjni_BodyCreationSettings * Method: setMotionQuality @@ -186,6 +522,18 @@ JNIEXPORT void JNICALL Java_com_github_stephengold_joltjni_BodyCreationSettings_ pSettings->mRestitution = restitution; } +/* + * Class: com_github_stephengold_joltjni_BodyCreationSettings + * Method: setRotation + * Signature: (JFFFF)V + */ +JNIEXPORT void JNICALL Java_com_github_stephengold_joltjni_BodyCreationSettings_setRotation + (JNIEnv *, jclass, jlong bodySettingsVa, jfloat qx, jfloat qy, jfloat qz, jfloat qw) { + BodyCreationSettings * const pSettings + = reinterpret_cast (bodySettingsVa); + pSettings->mRotation.Set(qx, qy, qz, qw); +} + /* * Class: com_github_stephengold_joltjni_BodyCreationSettings * Method: setShape