From 5fde943d9ef465b96a45aba53b090e90a9638ec8 Mon Sep 17 00:00:00 2001 From: Remi Beges Date: Thu, 14 Jun 2012 09:19:45 +0200 Subject: [PATCH 01/14] Fixed minor bug in NoiseBase & Vector4 (typo) --- include/Nazara/Math/Vector4.inl | 2 +- src/Nazara/Noise/NoiseBase.cpp | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/include/Nazara/Math/Vector4.inl b/include/Nazara/Math/Vector4.inl index 9073d37b0..168fb6714 100644 --- a/include/Nazara/Math/Vector4.inl +++ b/include/Nazara/Math/Vector4.inl @@ -361,7 +361,7 @@ NzVector4 operator/(T scale, const NzVector4& vec) throw std::domain_error(ss.ToString()); } - return NzVector3(scale / vec.x, scale / vec.y, scale / vec.z, scale / vec.w); + return NzVector4(scale / vec.x, scale / vec.y, scale / vec.z, scale / vec.w); } #include diff --git a/src/Nazara/Noise/NoiseBase.cpp b/src/Nazara/Noise/NoiseBase.cpp index 410e2b95d..7d5c9a53d 100644 --- a/src/Nazara/Noise/NoiseBase.cpp +++ b/src/Nazara/Noise/NoiseBase.cpp @@ -17,8 +17,8 @@ NzNoiseBase::NzNoiseBase(int seed) SetNewSeed(seed); - for(int i(0) ; i < 256 ; i++) - perm[i] = i; + for(int i(0) ; i < 512 ; i++) + perm[i] = i & 255; } From c55d9b5456708d3d0ef3015b60a042b64559af64 Mon Sep 17 00:00:00 2001 From: Remi Beges Date: Sat, 16 Jun 2012 13:28:47 +0200 Subject: [PATCH 02/14] Laid Physics module basis Added NzPhysicsWorld Added NzPhysicsSolver --- include/Nazara/Physics/Config.hpp | 38 +++++++++++++++++++++ include/Nazara/Physics/Debug.hpp | 11 +++++++ include/Nazara/Physics/DebugOff.hpp | 8 +++++ include/Nazara/Physics/Physics.hpp | 27 +++++++++++++++ include/Nazara/Physics/PhysicsSolver.hpp | 34 +++++++++++++++++++ include/Nazara/Physics/PhysicsWorld.hpp | 42 ++++++++++++++++++++++++ 6 files changed, 160 insertions(+) create mode 100644 include/Nazara/Physics/Config.hpp create mode 100644 include/Nazara/Physics/Debug.hpp create mode 100644 include/Nazara/Physics/DebugOff.hpp create mode 100644 include/Nazara/Physics/Physics.hpp create mode 100644 include/Nazara/Physics/PhysicsSolver.hpp create mode 100644 include/Nazara/Physics/PhysicsWorld.hpp diff --git a/include/Nazara/Physics/Config.hpp b/include/Nazara/Physics/Config.hpp new file mode 100644 index 000000000..a5af060c0 --- /dev/null +++ b/include/Nazara/Physics/Config.hpp @@ -0,0 +1,38 @@ +/* + Nazara Engine + + Copyright (C) 2012 AUTHORS (EMAIL) + + Permission is hereby granted, free of charge, to any person obtaining a copy of + this software and associated documentation files (the "Software"), to deal in + the Software without restriction, including without limitation the rights to + use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies + of the Software, and to permit persons to whom the Software is furnished to do + so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +*/ + +#pragma once + +#ifndef NAZARA_CONFIG_PHYSICS_HPP +#define NAZARA_CONFIG_PHYSICS_HPP + +/// Chaque modification d'un paramètre du module nécessite une recompilation de celui-ci + +// Utilise un tracker pour repérer les éventuels leaks (Ralentit l'exécution) +#define NAZARA_PHYSICS_MEMORYLEAKTRACKER 0 + +// Active les tests de sécurité basés sur le code (Conseillé pour le développement) +#define NAZARA_PHYSICS_SAFE 1 + +#endif // NAZARA_CONFIG_PHYSICS_HPP diff --git a/include/Nazara/Physics/Debug.hpp b/include/Nazara/Physics/Debug.hpp new file mode 100644 index 000000000..933d5db67 --- /dev/null +++ b/include/Nazara/Physics/Debug.hpp @@ -0,0 +1,11 @@ +// Copyright (C) 2012 AUTHORS +// This file is part of the "Nazara Engine". +// For conditions of distribution and use, see copyright notice in Config.hpp + +#include +#if NAZARA_PHYSICS_MEMORYLEAKTRACKER || defined(NAZARA_DEBUG) + #include + + #define delete NzMemoryManager::NextFree(__FILE__, __LINE__), delete + #define new new(__FILE__, __LINE__) +#endif diff --git a/include/Nazara/Physics/DebugOff.hpp b/include/Nazara/Physics/DebugOff.hpp new file mode 100644 index 000000000..813b9165e --- /dev/null +++ b/include/Nazara/Physics/DebugOff.hpp @@ -0,0 +1,8 @@ +// Copyright (C) 2012 AUTHORS +// This file is part of the "Nazara Engine". +// For conditions of distribution and use, see copyright notice in Config.hpp + +#if NAZARA_PHYSICS_MEMORYLEAKTRACKER || defined(NAZARA_DEBUG) + #undef delete + #undef new +#endif diff --git a/include/Nazara/Physics/Physics.hpp b/include/Nazara/Physics/Physics.hpp new file mode 100644 index 000000000..c36ce3fad --- /dev/null +++ b/include/Nazara/Physics/Physics.hpp @@ -0,0 +1,27 @@ +// Copyright (C) 2012 Jérôme Leclercq / Rémi Bèges +// This file is part of the "Nazara Engine". +// For conditions of distribution and use, see copyright notice in Config.hpp + +#pragma once + +#ifndef NAZARA_PHYSICS_HPP +#define NAZARA_PHYSICS_HPP + +#include + +class NAZARA_API NzPhysics +{ + public: + NzPhysics(); + ~NzPhysics(); + + bool Initialize(); + void Uninitialize(); + + static bool IsInitialized(); + + private: + static bool s_initialized; +}; + +#endif // NAZARA_PHYSICS_HPP diff --git a/include/Nazara/Physics/PhysicsSolver.hpp b/include/Nazara/Physics/PhysicsSolver.hpp new file mode 100644 index 000000000..86a7b0b17 --- /dev/null +++ b/include/Nazara/Physics/PhysicsSolver.hpp @@ -0,0 +1,34 @@ +// Copyright (C) 2012 Jérôme Leclercq / Rémi Bèges +// This file is part of the "Nazara Engine". +// For conditions of distribution and use, see copyright notice in Config.hpp + +#pragma once + +#ifndef PHYSICSSOLVER_HPP +#define PHYSICSSOLVER_HPP + +#include + +enum nzSolverMode +{ + nzExact, + nzAdaptative, + nzLinear +}; + +class NzPhysicsWorld; + +class NzPhysicsSolver +{ + public: + NzPhysicsSolver(nzSolverMode mode = nzLinear, unsigned int numberOfPassesLinearMode = 10); + void Configure(nzSolverMode mode, unsigned int numberOfPassesLinearMode); + void Set(NzPhysicsWorld* world); + ~NzPhysicsSolver(); + protected: + private: + nzSolverMode m_mode; + unsigned int m_numberOfPassesLinearMode; +}; + +#endif // PHYSICSSOLVER_HPP diff --git a/include/Nazara/Physics/PhysicsWorld.hpp b/include/Nazara/Physics/PhysicsWorld.hpp new file mode 100644 index 000000000..b0eda5f26 --- /dev/null +++ b/include/Nazara/Physics/PhysicsWorld.hpp @@ -0,0 +1,42 @@ +// Copyright (C) 2012 Jérôme Leclercq / Rémi Bèges +// This file is part of the "Nazara Engine". +// For conditions of distribution and use, see copyright notice in Config.hpp + +#pragma once + +#ifndef PHYSICSWORLD_HPP +#define PHYSICSWORLD_HPP + +#include +#include + +enum nzFrictionModel +{ + nzExact, + nzAdaptative +}; + +class NzPhysicsSolver; + +class NzPhysicsWorld +{ + public: + NzPhysicsWorld(); + ~NzPhysicsWorld(); + + void SetPhysicsSolver(const NzPhysicsSolver& solver); + const NzPhysicsSolver& GetPhysicsSolver() const; + + void SetFrictionModel(nzFrictionModel model); + const nzFrictionModel& GetFrictionModel(); + + void UpdatePhysics(nzUint64 timestep); + + protected: + private: + NewtonWorld* m_world; + NzPhysicsSolver m_solver; + nzFrictionModel m_frictionModel; +}; + +#endif // PHYSICSWORLD_HPP From 092ccd0302b82ff5d2f852c8fe8d6996cda5f239 Mon Sep 17 00:00:00 2001 From: Remi Beges Date: Sat, 16 Jun 2012 13:33:31 +0200 Subject: [PATCH 03/14] Forgot to commit src files and Newton headers in previous commit --- include/Newton/JointLibrary.h | 190 +++++ include/Newton/Newton.h | 1059 ++++++++++++++++++++++++++ src/Nazara/Physics/Physics.cpp | 57 ++ src/Nazara/Physics/PhysicsSolver.cpp | 46 ++ src/Nazara/Physics/PhysicsWorld.cpp | 60 ++ 5 files changed, 1412 insertions(+) create mode 100644 include/Newton/JointLibrary.h create mode 100644 include/Newton/Newton.h create mode 100644 src/Nazara/Physics/Physics.cpp create mode 100644 src/Nazara/Physics/PhysicsSolver.cpp create mode 100644 src/Nazara/Physics/PhysicsWorld.cpp diff --git a/include/Newton/JointLibrary.h b/include/Newton/JointLibrary.h new file mode 100644 index 000000000..df46b2300 --- /dev/null +++ b/include/Newton/JointLibrary.h @@ -0,0 +1,190 @@ +/* Copyright (c) <2009> +* +* This software is provided 'as-is', without any express or implied +* warranty. In no event will the authors be held liable for any damages +* arising from the use of this software. +* +* Permission is granted to anyone to use this software for any purpose, +* including commercial applications, and to alter it and redistribute it +* freely +*/ + +#ifndef NEWTON_CUSTOM_JOINTS_H_INCLUDED_ +#define NEWTON_CUSTOM_JOINTS_H_INCLUDED_ + + +#include "Newton.h" +//#include "CustomJointLibraryStdAfx.h" + +#ifdef _NEWTON_STATIC_LIB + #define JOINTLIBRARY_API +#else + #ifdef JOINTLIBRARY_LIB + #define JOINTLIBRARY_API + #else + #ifdef JOINTLIBRARY_EXPORTS + #define JOINTLIBRARY_API __declspec(dllexport) + #else + #define JOINTLIBRARY_API __declspec(dllimport) + #endif + #endif +#endif + + + + +#ifdef __cplusplus +extern "C" { +#endif + + // Generic joint call back and user data + typedef struct NewtonUserJoint{} NewtonUserJoint; + typedef void (*NewtonUserJointDestructorCallback) (const NewtonUserJoint* me); + typedef void (*NewtonUserJointSubmitConstraintCallback) (const NewtonUserJoint* me, dFloat timestep, int threadIndex); + + + // generic joint functions + JOINTLIBRARY_API void CustomDestroyJoint(const NewtonUserJoint *joint); + JOINTLIBRARY_API NewtonJoint* CustomGetNewtonJoint (const NewtonUserJoint *joint); + JOINTLIBRARY_API int CustomGetJointID (const NewtonUserJoint *joint); + JOINTLIBRARY_API void CustomSetJointID (const NewtonUserJoint *joint, int rttI); + JOINTLIBRARY_API const NewtonBody* CustomGetBody0 (const NewtonUserJoint *joint); + JOINTLIBRARY_API const NewtonBody* CustomGetBody1 (const NewtonUserJoint *joint); + JOINTLIBRARY_API int CustomGetBodiesCollisionState (const NewtonUserJoint *joint); + JOINTLIBRARY_API void CustomSetBodiesCollisionState (const NewtonUserJoint *joint, int state); + JOINTLIBRARY_API void* CustomGetUserData (const NewtonUserJoint *joint); + JOINTLIBRARY_API void CustomSetUserData (const NewtonUserJoint *joint, void* userData); + JOINTLIBRARY_API void CustomSetDestructorCallback (const NewtonUserJoint *joint, NewtonUserJointDestructorCallback callback); + JOINTLIBRARY_API void CustomSetSubmitContraintCallback (const NewtonUserJoint *joint, NewtonUserJointSubmitConstraintCallback callback); + + + // this is a plain blank joint that can be used by advanced users who want to make their own joints + // but that can only use languages that can only interface with C code. + // we recommend using the CPP library to make the joints and then add a C interface, but this join is here for completion + typedef void (*BlankJointGetInfo) (const NewtonUserJoint* me, NewtonJointRecord* info); + JOINTLIBRARY_API NewtonUserJoint* CustomCreateBlankJoint(int maxDof, const NewtonBody* body0, const NewtonBody* body1, BlankJointGetInfo info); + + // Kinematic control joint + JOINTLIBRARY_API NewtonUserJoint *CreateCustomKinematicController (const NewtonBody* targetBody, dFloat* attachmentPointInGlobalSpace); + JOINTLIBRARY_API void CustomKinematicControllerSetPickMode (const NewtonUserJoint *pick, int mode); + JOINTLIBRARY_API void CustomKinematicControllerSetMaxLinearFriction(const NewtonUserJoint *pick, dFloat accel); + JOINTLIBRARY_API void CustomKinematicControllerSetMaxAngularFriction(const NewtonUserJoint *pick, dFloat alpha); + JOINTLIBRARY_API void CustomKinematicControllerSetTargetPosit (const NewtonUserJoint *pick, dFloat* posit); + JOINTLIBRARY_API void CustomKinematicControllerSetTargetRotation (const NewtonUserJoint *pick, dFloat* rotation); + JOINTLIBRARY_API void CustomKinematicControllerSetTargetMatrix (const NewtonUserJoint *pick, dFloat* matrix); + JOINTLIBRARY_API void CustomKinematicControllerGetTargetMatrix (const NewtonUserJoint *pick, dFloat* matrix); + + // Generic 6 degree of Freedom Joint + JOINTLIBRARY_API NewtonUserJoint *CreateCustomJoint6DOF (const dFloat* pinsAndPivotChildFrame, const dFloat* pinsAndPivotParentFrame, const NewtonBody* child, const NewtonBody* parent); + JOINTLIBRARY_API void CustomJoint6DOF_SetLinearLimits (NewtonUserJoint* customJoint6DOF, const dFloat* minLinearLimits, const dFloat* maxLinearLimits); + JOINTLIBRARY_API void CustomJoint6DOF_SetAngularLimits (NewtonUserJoint* customJoint6DOF, const dFloat* minAngularLimits, const dFloat* maxAngularLimits); + JOINTLIBRARY_API void CustomJoint6DOF_GetLinearLimits (NewtonUserJoint* customJoint6DOF, dFloat* minLinearLimits, dFloat* maxLinearLimits); + JOINTLIBRARY_API void CustomJoint6DOF_GetAngularLimits (NewtonUserJoint* customJoint6DOF, dFloat* minAngularLimits, dFloat* maxAngularLimits); + JOINTLIBRARY_API void CustomJoint6DOF_SetReverseUniversal (NewtonUserJoint* customJoint6DOF, int order); + + + // Interface for a custom BallAndSocket joint with Limits + JOINTLIBRARY_API NewtonUserJoint *CreateCustomBallAndSocket (const dFloat* pinsAndPivotChildFrame, const NewtonBody* child, const NewtonBody* parent); + JOINTLIBRARY_API void BallAndSocketSetConeAngle (NewtonUserJoint* ballJoint, dFloat angle); + JOINTLIBRARY_API void BallAndSocketSetTwistAngle (NewtonUserJoint* ballJoint, dFloat minAngle, dFloat maxAngle); + + // Interface for a custom Hinge joint with Limits + JOINTLIBRARY_API NewtonUserJoint *CreateCustomHinge (const dFloat* pinsAndPivotChildFrame, const NewtonBody* child, const NewtonBody* parent); + JOINTLIBRARY_API void HingeEnableLimits(NewtonUserJoint* hingeJoint, int state); + JOINTLIBRARY_API void HingeSetLimits (NewtonUserJoint* hingeJoint, dFloat minAngle, dFloat maxAngle); + JOINTLIBRARY_API dFloat HingeGetJointAngle (const NewtonUserJoint* hingeJoint); + JOINTLIBRARY_API void HingeGetPinAxis (const NewtonUserJoint* hingeJoint, dFloat* pin); + JOINTLIBRARY_API dFloat HingeCalculateJointOmega (const NewtonUserJoint* hingeJoint); + + // Interface for a custom Slider joint with Limits + JOINTLIBRARY_API NewtonUserJoint *CreateCustomSlider (const dFloat* pinsAndPivotChildFrame, const NewtonBody* child, const NewtonBody* parent); + JOINTLIBRARY_API void SliderEnableLimits(NewtonUserJoint* sliderJoint, int state); + JOINTLIBRARY_API void SliderSetLimits (NewtonUserJoint* sliderJoint, dFloat mindist, dFloat maxdist); + + + + // player controller functions +// typedef int (*PlayerCanPuchThisBodyCalback) (NewtonUserJoint *me, const NewtonBody* hitBody); + JOINTLIBRARY_API NewtonUserJoint *CreateCustomPlayerController (const dFloat* pins, const NewtonBody* player, dFloat maxStairStepFactor, dFloat cushion); + JOINTLIBRARY_API void CustomPlayerControllerSetVelocity (const NewtonUserJoint* playerController, dFloat forwardSpeed, dFloat sideSpeed, dFloat heading); + JOINTLIBRARY_API void CustomPlayerControllerGetVisualMaTrix (const NewtonUserJoint* playerController, dFloat* matrix); + JOINTLIBRARY_API dFloat CustomPlayerControllerGetMaxSlope (const NewtonUserJoint* playerController); + JOINTLIBRARY_API void CustomPlayerControllerSetMaxSlope (const NewtonUserJoint* playerController, dFloat maxSlopeAngleIndRadian); + JOINTLIBRARY_API const NewtonCollision* CustomPlayerControllerGetSensorShape (const NewtonUserJoint* playerController); + + +// JOINTLIBRARY_API void CustomPlayerControllerSetPushActorCallback (NewtonUserJoint* playerController, PlayerCanPuchThisBodyCalback callback); +// JOINTLIBRARY_API const NewtonCollision* CustomPlayerControllerGetVerticalSensorShape (NewtonUserJoint* playerController); +// JOINTLIBRARY_API const NewtonCollision* CustomPlayerControllerGetDynamicsSensorShape (NewtonUserJoint* playerController); + + // Multi rigid BodyCar controller functions +// JOINTLIBRARY_API NewtonUserJoint *CreateCustomMultiBodyVehicle (const dFloat* frontDir, const dFloat* upDir, const NewtonBody* carBody); +// JOINTLIBRARY_API int CustomMultiBodyVehicleAddTire (NewtonUserJoint *car, const void* userData, const dFloat* localPosition, +// dFloat mass, dFloat radius, dFloat width, +// dFloat suspensionLength, dFloat springConst, dFloat springDamper); +// JOINTLIBRARY_API int CustomMultiBodyVehicleAddSlipDifferencial (NewtonUserJoint *car, int leftTireIndex, int rightToreIndex, dFloat maxFriction); +// JOINTLIBRARY_API int CustomMultiBodyVehicleGetTiresCount(NewtonUserJoint *car); +// JOINTLIBRARY_API const NewtonBody* CustomMultiBodyVehicleGetTireBody(NewtonUserJoint *car, int tireIndex); +// JOINTLIBRARY_API dFloat CustomMultiBodyVehicleGetSpeed(NewtonUserJoint *car); +// JOINTLIBRARY_API dFloat CustomMultiBodyVehicleGetTireSteerAngle (NewtonUserJoint *car, int index); +// JOINTLIBRARY_API void CustomMultiBodyVehicleApplyTorque (NewtonUserJoint *car, int tireIndex, dFloat torque); +// JOINTLIBRARY_API void CustomMultiBodyVehicleApplySteering (NewtonUserJoint *car, int tireIndex, dFloat angle); +// JOINTLIBRARY_API void CustomMultiBodyVehicleApplyBrake (NewtonUserJoint *car, int tireIndex, dFloat brakeTorque); +// JOINTLIBRARY_API void CustomMultiBodyVehicleApplyTireRollingDrag (NewtonUserJoint *car, int index, dFloat angularDampingCoef); + + + // BEGIN k00m (Dave Gravel simple ray cast world vehicle) + typedef void (*DGRaycastVehicleTireTransformCallback) (NewtonUserJoint *car); + JOINTLIBRARY_API NewtonUserJoint *DGRaycastVehicleCreate (int maxTireCount, const dFloat* cordenateSytemInLocalSpace, NewtonBody* carBody); + JOINTLIBRARY_API void DGRaycastVehicleAddTire (NewtonUserJoint *car, void *userData, const dFloat* localPosition, dFloat mass, dFloat radius, dFloat width, dFloat friction, dFloat suspensionLength, dFloat springConst, dFloat springDamper, int castMode); + JOINTLIBRARY_API void DGRaycastVehicleSetTireTransformCallback (NewtonUserJoint *car, DGRaycastVehicleTireTransformCallback callback); + JOINTLIBRARY_API int DGRaycastVehicleGetTiresCount(NewtonUserJoint *car); + JOINTLIBRARY_API void* DGRaycastVehicleGetTiresUserData(NewtonUserJoint *car, int tireIndex); + JOINTLIBRARY_API void DGRaycastVehicleGetTireMatrix(NewtonUserJoint *car, int tireIndex, dFloat* tireMatrix); + + JOINTLIBRARY_API void DGRaycastVehicleInitNormalizeTireLateralForce(NewtonUserJoint *car, int pointsCount, dFloat* const piceSizeStepAxis, dFloat* const normalizedForceValue); + JOINTLIBRARY_API void DGRaycastVehicleInitNormalizeTireLongitudinalForce(NewtonUserJoint *car, int pointsCount, dFloat* const piceSizeStepAxis, dFloat* const normalizedForceValue); + + +// JOINTLIBRARY_API void DGRayCarGetChassisMatrixLocal(NewtonUserJoint *car, dFloat* chassisMatrix); +// JOINTLIBRARY_API void DGRayCarTireMatrix(NewtonUserJoint *car, int tire, dFloat* tireMatrix); +// JOINTLIBRARY_API void DGRayCarSuspensionMatrix(NewtonUserJoint *car, int tire, dFloat param, dFloat* SuspensionMatrix); +// JOINTLIBRARY_API const NewtonCollision* DGRayCarTireShape(NewtonUserJoint *car, int tireIndex); +// JOINTLIBRARY_API dFloat DGRaycastVehicleGetSpeed(NewtonUserJoint *car); +// JOINTLIBRARY_API void DGRaycastVehicleSetCustomTireBrake (NewtonUserJoint *car, int index, dFloat torque); +// JOINTLIBRARY_API void DGRaycastVehicleSetCustomTireTorque (NewtonUserJoint *car, int index, dFloat torque); +// JOINTLIBRARY_API void DGRaycastVehicleSetCustomTireSteerAngleForce (NewtonUserJoint *car, int index, dFloat angle, dFloat turnforce); +// JOINTLIBRARY_API dFloat DGRaycastVehicleGenerateTiresBrake (NewtonUserJoint *car, dFloat value); +// JOINTLIBRARY_API dFloat DGRaycastVehicleGenerateTiresTorque (NewtonUserJoint *car, dFloat value); +// JOINTLIBRARY_API dFloat DGRaycastVehicleGenerateTiresSteerForce (NewtonUserJoint *car, dFloat value); +// JOINTLIBRARY_API dFloat DGRaycastVehicleGenerateTiresSteerAngle (NewtonUserJoint *car, dFloat value); +// JOINTLIBRARY_API void DGRaycastVehicleSetVarTireMovePointForceFront (NewtonUserJoint *car, int index, dFloat distance); +// JOINTLIBRARY_API void DGRaycastVehicleSetVarTireMovePointForceRight (NewtonUserJoint *car, int index, dFloat distance); +// JOINTLIBRARY_API void DGRaycastVehicleSetVarTireMovePointForceUp (NewtonUserJoint *car, int index, dFloat distance); +// JOINTLIBRARY_API void DGRaycastVehicleSetVarFixDeceleration (NewtonUserJoint *car, dFloat value); +// JOINTLIBRARY_API void DGRaycastVehicleSetVarChassisRotationLimit (NewtonUserJoint *car, dFloat value); +// JOINTLIBRARY_API void DGRaycastVehicleSetVarMaxSteerAngle (NewtonUserJoint *car, dFloat value); +// JOINTLIBRARY_API void DGRaycastVehicleSetVarMaxSteerRate (NewtonUserJoint *car, dFloat value); +// JOINTLIBRARY_API void DGRaycastVehicleSetVarMaxSteerForceRate (NewtonUserJoint *car, dFloat value); +// JOINTLIBRARY_API void DGRaycastVehicleSetVarMaxSteerForce (NewtonUserJoint *car, dFloat value); +// JOINTLIBRARY_API void DGRaycastVehicleSetVarMaxSteerSpeedRestriction (NewtonUserJoint *car, dFloat value); +// JOINTLIBRARY_API void DGRaycastVehicleSetVarMaxBrakeForce (NewtonUserJoint *car, dFloat value); +// JOINTLIBRARY_API void DGRaycastVehicleSetVarMaxTorque (NewtonUserJoint *car, dFloat value); +// JOINTLIBRARY_API void DGRaycastVehicleSetVarMaxTorqueRate (NewtonUserJoint *car, dFloat value); +// JOINTLIBRARY_API void DGRaycastVehicleSetVarEngineSteerDiv (NewtonUserJoint *car, dFloat value); +// JOINTLIBRARY_API void DGRaycastVehicleSetVarTireSuspenssionHardLimit (NewtonUserJoint *car, int index, dFloat value); +// JOINTLIBRARY_API void DGRaycastVehicleSetVarTireFriction (NewtonUserJoint *car, int index, dFloat value); +// JOINTLIBRARY_API int DGRaycastVehicleGetVehicleOnAir(NewtonUserJoint *car); +// JOINTLIBRARY_API int DGRaycastVehicleGetTireOnAir(NewtonUserJoint *car, int index); +// JOINTLIBRARY_API void DGRaycastVehicleDestroy (NewtonUserJoint *car); +// END + + + + +#ifdef __cplusplus +} +#endif + + +#endif diff --git a/include/Newton/Newton.h b/include/Newton/Newton.h new file mode 100644 index 000000000..e6fa2d770 --- /dev/null +++ b/include/Newton/Newton.h @@ -0,0 +1,1059 @@ +/* Copyright (c) <2003-2011> + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any damages + * arising from the use of this software. + * + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you must not + * claim that you wrote the original software. If you use this software + * in a product, an acknowledgment in the product documentation would be + * appreciated but is not required. + * + * 2. Altered source versions must be plainly marked as such, and must not be + * misrepresented as being the original software. + * + * 3. This notice may not be removed or altered from any source distribution. + */ + +#ifndef NEWTON_H__736495_6495_076__INCLUDED_ +#define NEWTON_H__736495_6495_076__INCLUDED_ + + +#define NEWTON_MAJOR_VERSION 2 +#define NEWTON_MINOR_VERSION 35 + + +#ifdef _NEWTON_STATIC_LIB + #define NEWTON_API +#else + #ifdef _NEWTON_BUILD_DLL + #ifdef _WIN32 + #define NEWTON_API __declspec (dllexport) + #else + #define NEWTON_API __attribute__ ((visibility("default"))) + #endif + #else + #ifdef _WIN32 + #define NEWTON_API __declspec (dllimport) + #else + #define NEWTON_API + #endif + #endif +#endif + + +#ifdef __USE_DOUBLE_PRECISION__ + #define dFloat double +#else + #define dFloat float +#endif + +#define dFloat64 double + + +#ifdef __cplusplus +extern "C" { +#endif + +#define NEWTON_PROFILER_WORLD_UPDATE 0 + +#define NEWTON_PROFILER_COLLISION_UPDATE 1 +#define NEWTON_PROFILER_COLLISION_UPDATE_BROAD_PHASE 2 +#define NEWTON_PROFILER_COLLISION_UPDATE_NARROW_PHASE 3 + +#define NEWTON_PROFILER_DYNAMICS_UPDATE 4 +#define NEWTON_PROFILER_DYNAMICS_CONSTRAINT_GRAPH 5 +#define NEWTON_PROFILER_DYNAMICS_SOLVE_CONSTRAINT_GRAPH 6 + +#define NEWTON_PROFILER_FORCE_CALLBACK_UPDATE 7 + + +typedef struct NewtonMesh{} NewtonMesh; +typedef struct NewtonBody{} NewtonBody; +typedef struct NewtonWorld{} NewtonWorld; +typedef struct NewtonJoint{} NewtonJoint; +typedef struct NewtonMaterial{} NewtonMaterial; +typedef struct NewtonCollision{} NewtonCollision; +typedef struct NewtonSceneProxy{} NewtonSceneProxy; +typedef struct NewtonbreakableComponentMesh{} NewtonbreakableComponentMesh; + +// typedef struct NewtonRagDoll{} NewtonRagDoll; +// typedef struct NewtonRagDollBone{} NewtonRagDollBone; + +#define SERIALIZE_ID_BOX 0 +#define SERIALIZE_ID_CONE 1 +#define SERIALIZE_ID_SPHERE 2 +#define SERIALIZE_ID_CAPSULE 3 +#define SERIALIZE_ID_CYLINDER 4 +#define SERIALIZE_ID_COMPOUND 5 +#define SERIALIZE_ID_CONVEXHULL 6 +#define SERIALIZE_ID_CONVEXMODIFIER 7 +#define SERIALIZE_ID_CHAMFERCYLINDER 8 +#define SERIALIZE_ID_TREE 9 +#define SERIALIZE_ID_NULL 10 +#define SERIALIZE_ID_HEIGHTFIELD 11 +#define SERIALIZE_ID_USERMESH 12 +#define SERIALIZE_ID_SCENE 13 +#define SERIALIZE_ID_COMPOUND_BREAKABLE 14 + +typedef struct NewtonBoxParam NewtonBoxParam; +typedef struct NewtonConeParam NewtonConeParam; +typedef struct NewtonSphereParam NewtonSphereParam; +typedef struct NewtonCapsuleParam NewtonCapsuleParam; +typedef struct NewtonCylinderParam NewtonCylinderParam; +typedef struct NewtonConvexHullParam NewtonConvexHullParam; +typedef struct NewtonCollisionTreeParam NewtonCollisionTreeParam; +typedef struct NewtonSceneCollisionParam NewtonSceneCollisionParam; +typedef struct NewtonChamferCylinderParam NewtonChamferCylinderParam; +typedef struct NewtonCompoundCollisionParam NewtonCompoundCollisionParam; +typedef struct NewtonConvexHullModifierParam NewtonConvexHullModifierParam; +typedef struct NewtonHeightFieldCollisionParam NewtonHeightFieldCollisionParam; + +typedef struct NewtonCollisionInfoRecord NewtonCollisionInfoRecord; + +struct NewtonBoxParam +{ + dFloat m_x; + dFloat m_y; + dFloat m_z; +}; + +struct NewtonSphereParam +{ + dFloat m_r0; + dFloat m_r1; + dFloat m_r2; +}; + +struct NewtonCylinderParam +{ + dFloat m_r0; + dFloat m_r1; + dFloat m_height; +}; + +struct NewtonCapsuleParam +{ + dFloat m_r0; + dFloat m_r1; + dFloat m_height; +}; + +struct NewtonConeParam +{ + dFloat m_r; + dFloat m_height; +}; + +struct NewtonChamferCylinderParam +{ + dFloat m_r; + dFloat m_height; +}; + +struct NewtonConvexHullParam +{ + int m_vertexCount; + int m_vertexStrideInBytes; + int m_faceCount; + dFloat* m_vertex; +}; + +struct NewtonConvexHullModifierParam +{ + NewtonCollision* m_chidren; +}; + + +struct NewtonCompoundCollisionParam +{ + int m_chidrenCount; + NewtonCollision** m_chidren; +}; + +struct NewtonCollisionTreeParam +{ + int m_vertexCount; + int m_indexCount; +}; + +struct NewtonHeightFieldCollisionParam +{ + int m_width; + int m_height; + int m_gridsDiagonals; + dFloat m_horizonalScale; + dFloat m_verticalScale; + unsigned short *m_elevation; + char *m_atributes; +}; + +struct NewtonSceneCollisionParam +{ + int m_childrenProxyCount; +}; + +struct NewtonCollisionInfoRecord +{ + dFloat m_offsetMatrix[4][4]; + int m_collisionType; // tag id to identify the collision primitive + int m_referenceCount; // the current reference count for this collision + int m_collisionUserID; + + union { + NewtonBoxParam m_box; + NewtonConeParam m_cone; + NewtonSphereParam m_sphere; + NewtonCapsuleParam m_capsule; + NewtonCylinderParam m_cylinder; + NewtonChamferCylinderParam m_chamferCylinder; + NewtonConvexHullParam m_convexHull; + NewtonCompoundCollisionParam m_compoundCollision; + NewtonConvexHullModifierParam m_convexHullModifier; + NewtonCollisionTreeParam m_collisionTree; + NewtonHeightFieldCollisionParam m_heightField; + NewtonSceneCollisionParam m_sceneCollision; + dFloat m_paramArray[64]; // user define collision can use this to store information + }; +}; + + +typedef struct NewtonJointRecord NewtonJointRecord; +typedef struct NewtonHingeSliderUpdateDesc NewtonHingeSliderUpdateDesc; +typedef struct NewtonUserMeshCollisionRayHitDesc NewtonUserMeshCollisionRayHitDesc; +typedef struct NewtonUserMeshCollisionCollideDesc NewtonUserMeshCollisionCollideDesc; +typedef struct NewtonWorldConvexCastReturnInfo NewtonWorldConvexCastReturnInfo; + + +struct NewtonJointRecord +{ + dFloat m_attachmenMatrix_0[4][4]; + dFloat m_attachmenMatrix_1[4][4]; + dFloat m_minLinearDof[3]; + dFloat m_maxLinearDof[3]; + dFloat m_minAngularDof[3]; + dFloat m_maxAngularDof[3]; + const NewtonBody* m_attachBody_0; + const NewtonBody* m_attachBody_1; + dFloat m_extraParameters[16]; + int m_bodiesCollisionOn; + char m_descriptionType[32]; +} ; + + + +struct NewtonUserMeshCollisionCollideDesc +{ + dFloat m_boxP0[4]; // lower bounding box of intersection query in local space + dFloat m_boxP1[4]; // upper bounding box of intersection query in local space + int m_threadNumber; // current thread executing this query + int m_faceCount; // the application should set here how many polygons intersect the query box + int m_vertexStrideInBytes; // the application should set here the size of each vertex + void* m_userData; // user data passed to the collision geometry at creation time + dFloat* m_vertex; // the application should the pointer to the vertex array. + int* m_userAttribute; // the application should set here the pointer to the user data, one for each face + int* m_faceIndexCount; // the application should set here the pointer to the vertex count of each face. + int* m_faceVertexIndex; // the application should set here the pointer index array for each vertex on a face. + NewtonBody* m_objBody; // pointer to the colliding body + NewtonBody* m_polySoupBody; // pointer to the rigid body owner of this collision tree +}; + +struct NewtonWorldConvexCastReturnInfo +{ + dFloat m_point[4]; // collision point in global space + dFloat m_normal[4]; // surface normal at collision point in global space + dFloat m_normalOnHitPoint[4]; // surface normal at the surface of the hit body, + // is the same as the normal calculated by a ray cast hitting the body at the hit point + dFloat m_penetration; // contact penetration at collision point + int m_contactID; // collision ID at contact point + const NewtonBody* m_hitBody; // body hit at contact point +}; + +struct NewtonUserMeshCollisionRayHitDesc +{ + dFloat m_p0[4]; // ray origin in collision local space + dFloat m_p1[4]; // ray destination in collision local space + dFloat m_normalOut[4]; // copy here the normal at the ray intersection + int m_userIdOut; // copy here a user defined id for further feedback + void* m_userData; // user data passed to the collision geometry at creation time +}; + +struct NewtonHingeSliderUpdateDesc +{ + dFloat m_accel; + dFloat m_minFriction; + dFloat m_maxFriction; + dFloat m_timestep; +} ; + + +// Newton callback functions +typedef void* (*NewtonAllocMemory) (int sizeInBytes); +typedef void (*NewtonFreeMemory) (void* const ptr, int sizeInBytes); +typedef void (*NewtonDestroyWorld) (const NewtonWorld* const newtonWorld); + +typedef unsigned (*NewtonGetTicksCountCallback) (); + +typedef void (*NewtonSerialize) (void* const serializeHandle, const void* buffer, int size); +typedef void (*NewtonDeserialize) (void* const serializeHandle, void* buffer, int size); + +// user collision callbacks +typedef void (*NewtonUserMeshCollisionDestroyCallback) (void* const userData); +typedef void (*NewtonUserMeshCollisionCollideCallback) (NewtonUserMeshCollisionCollideDesc* const collideDescData); +typedef dFloat (*NewtonUserMeshCollisionRayHitCallback) (NewtonUserMeshCollisionRayHitDesc* const lineDescData); +typedef void (*NewtonUserMeshCollisionGetCollisionInfo) (void* const userData, NewtonCollisionInfoRecord* const infoRecord); +typedef int (*NewtonUserMeshCollisionGetFacesInAABB) (void* const userData, const dFloat* const p0, const dFloat* const p1, + const dFloat** const vertexArray, int* const vertexCount, int* const vertexStrideInBytes, + const int* const indexList, int maxIndexCount, const int* const userDataList); + +typedef dFloat (*NewtonCollisionTreeRayCastCallback) (const NewtonBody* const body, const NewtonCollision* const treeCollision, dFloat interception, dFloat* normal, int faceId, void* usedData); +typedef dFloat (*NewtonHeightFieldRayCastCallback) (const NewtonBody* const body, const NewtonCollision* const heightFieldCollision, dFloat interception, int row, int col, dFloat* normal, int faceId, void* usedData); + + +// collision tree call back (obsoleted no recommended) +typedef void (*NewtonTreeCollisionCallback) (const NewtonBody* const bodyWithTreeCollision, const NewtonBody* const body, int faceID, + int vertexCount, const dFloat* const vertex, int vertexStrideInBytes); + +typedef void (*NewtonBodyDestructor) (const NewtonBody* const body); +typedef void (*NewtonApplyForceAndTorque) (const NewtonBody* const body, dFloat timestep, int threadIndex); +typedef void (*NewtonSetTransform) (const NewtonBody* const body, const dFloat* const matrix, int threadIndex); + +typedef int (*NewtonIslandUpdate) (const NewtonWorld* const newtonWorld, const void* islandHandle, int bodyCount); +typedef void (*NewtonBodyLeaveWorld) (const NewtonBody* const body, int threadIndex); +typedef void (*NewtonDestroyBodyByExeciveForce) (const NewtonBody* const body, const NewtonJoint* const contact); +typedef void (*NewtonCollisionDestructor) (const NewtonWorld* const newtonWorld, const NewtonCollision* const collision); + +typedef int (*NewtonCollisionCompoundBreakableCallback) (NewtonMesh* const mesh, void* const userData, dFloat* const planeMatrixOut); + +typedef int (*NewtonGetBuoyancyPlane) (const int collisionID, void* const context, const dFloat* const globalSpaceMatrix, dFloat* const globalSpacePlane); +typedef unsigned (*NewtonWorldRayPrefilterCallback)(const NewtonBody* const body, const NewtonCollision* const collision, void* const userData); +typedef dFloat (*NewtonWorldRayFilterCallback)(const NewtonBody* const body, const dFloat* const hitNormal, int collisionID, void* const userData, dFloat intersectParam); + + +typedef int (*NewtonOnAABBOverlap) (const NewtonMaterial* const material, const NewtonBody* const body0, const NewtonBody* const body1, int threadIndex); +typedef void (*NewtonContactsProcess) (const NewtonJoint* const contact, dFloat timestep, int threadIndex); + +typedef void (*NewtonBodyIterator) (const NewtonBody* const body, void* const userData); +typedef void (*NewtonJointIterator) (const NewtonJoint* const joint, void* const userData); +typedef void (*NewtonCollisionIterator) (void* const userData, int vertexCount, const dFloat* const faceArray, int faceId); + +typedef void (*NewtonBallCallBack) (const NewtonJoint* const ball, dFloat timestep); +typedef unsigned (*NewtonHingeCallBack) (const NewtonJoint* const hinge, NewtonHingeSliderUpdateDesc* const desc); +typedef unsigned (*NewtonSliderCallBack) (const NewtonJoint* const slider, NewtonHingeSliderUpdateDesc* const desc); +typedef unsigned (*NewtonUniversalCallBack) (const NewtonJoint* const universal, NewtonHingeSliderUpdateDesc* const desc); +typedef unsigned (*NewtonCorkscrewCallBack) (const NewtonJoint* const corkscrew, NewtonHingeSliderUpdateDesc* const desc); + +typedef void (*NewtonUserBilateralCallBack) (const NewtonJoint* const userJoint, dFloat timestep, int threadIndex); +typedef void (*NewtonUserBilateralGetInfoCallBack) (const NewtonJoint* const userJoint, NewtonJointRecord* const info); + +typedef void (*NewtonConstraintDestructor) (const NewtonJoint*const me); + +// typedef void (*NewtonSetRagDollTransform) (const NewtonRagDollBone* const bone); +// typedef void (*NewtonBodyActivationState) (const NewtonBody* const body, unsigned state); +// typedef void (*NewtonVehicleTireUpdate) (const NewtonJoint* const vehicle, dFloat timestep); + + +// ********************************************************************************************** +// +// world control functions +// +// ********************************************************************************************** +NEWTON_API int NewtonWorldGetVersion (); +NEWTON_API int NewtonWorldFloatSize (); + +NEWTON_API int NewtonGetMemoryUsed (); +NEWTON_API void NewtonSetMemorySystem (NewtonAllocMemory malloc, NewtonFreeMemory mfree); + +NEWTON_API NewtonWorld* NewtonCreate (); +NEWTON_API void NewtonDestroy (const NewtonWorld* const newtonWorld); +NEWTON_API void NewtonDestroyAllBodies (const NewtonWorld* const newtonWorld); + +NEWTON_API void NewtonUpdate (const NewtonWorld* const newtonWorld, dFloat timestep); +NEWTON_API void NewtonInvalidateCache (const NewtonWorld* const newtonWorld); +NEWTON_API void NewtonCollisionUpdate (const NewtonWorld* const newtonWorld); + +NEWTON_API void NewtonSetSolverModel (const NewtonWorld* const newtonWorld, int model); +NEWTON_API void NewtonSetPlatformArchitecture (const NewtonWorld* const newtonWorld, int mode); +NEWTON_API int NewtonGetPlatformArchitecture(const NewtonWorld* const newtonWorld, char* description); +NEWTON_API void NewtonSetMultiThreadSolverOnSingleIsland (const NewtonWorld* const newtonWorld, int mode); +NEWTON_API int NewtonGetMultiThreadSolverOnSingleIsland (const NewtonWorld* const newtonWorld); + +NEWTON_API void NewtonSetPerformanceClock (const NewtonWorld* const newtonWorld, NewtonGetTicksCountCallback callback); +NEWTON_API unsigned NewtonReadPerformanceTicks (const NewtonWorld* const newtonWorld, unsigned performanceEntry); +NEWTON_API unsigned NewtonReadThreadPerformanceTicks (const NewtonWorld* newtonWorld, unsigned threadIndex); + +NEWTON_API void NewtonWorldCriticalSectionLock (const NewtonWorld* const newtonWorld); +NEWTON_API void NewtonWorldCriticalSectionUnlock (const NewtonWorld* const newtonWorld); +NEWTON_API void NewtonSetThreadsCount (const NewtonWorld* const newtonWorld, int threads); +NEWTON_API int NewtonGetThreadsCount(const NewtonWorld* const newtonWorld); +NEWTON_API int NewtonGetMaxThreadsCount(const NewtonWorld* const newtonWorld); + +NEWTON_API void NewtonSetFrictionModel (const NewtonWorld* const newtonWorld, int model); +NEWTON_API void NewtonSetMinimumFrameRate (const NewtonWorld* const newtonWorld, dFloat frameRate); +NEWTON_API void NewtonSetBodyLeaveWorldEvent (const NewtonWorld* const newtonWorld, NewtonBodyLeaveWorld callback); +NEWTON_API void NewtonSetWorldSize (const NewtonWorld* const newtonWorld, const dFloat* const minPoint, const dFloat* const maxPoint); +NEWTON_API void NewtonSetIslandUpdateEvent (const NewtonWorld* const newtonWorld, NewtonIslandUpdate islandUpdate); +NEWTON_API void NewtonSetCollisionDestructor (const NewtonWorld* const newtonWorld, NewtonCollisionDestructor callback); +NEWTON_API void NewtonSetDestroyBodyByExeciveForce (const NewtonWorld* const newtonWorld, NewtonDestroyBodyByExeciveForce callback); + + +// NEWTON_API void NewtonWorldForEachBodyDo (const NewtonWorld* const newtonWorld, NewtonBodyIterator callback); +NEWTON_API void NewtonWorldForEachJointDo (const NewtonWorld* const newtonWorld, NewtonJointIterator callback, void* const userData); +NEWTON_API void NewtonWorldForEachBodyInAABBDo (const NewtonWorld* const newtonWorld, const dFloat* const p0, const dFloat* const p1, NewtonBodyIterator callback, void* const userData); + + +NEWTON_API void NewtonWorldSetUserData (const NewtonWorld* const newtonWorld, void* const userData); +NEWTON_API void* NewtonWorldGetUserData (const NewtonWorld* const newtonWorld); +NEWTON_API void NewtonWorldSetDestructorCallBack (const NewtonWorld* const newtonWorld, NewtonDestroyWorld destructor); +NEWTON_API NewtonDestroyWorld NewtonWorldGetDestructorCallBack (const NewtonWorld* const newtonWorld); + +NEWTON_API void NewtonWorldRayCast (const NewtonWorld* const newtonWorld, const dFloat* const p0, const dFloat* const p1, NewtonWorldRayFilterCallback filter, void* const userData, + NewtonWorldRayPrefilterCallback prefilter); +NEWTON_API int NewtonWorldConvexCast (const NewtonWorld* const newtonWorld, const dFloat* const matrix, const dFloat* const target, const NewtonCollision* shape, dFloat* const hitParam, void* const userData, + NewtonWorldRayPrefilterCallback prefilter, NewtonWorldConvexCastReturnInfo* info, int maxContactsCount, int threadIndex); + + +// world utility functions +NEWTON_API int NewtonWorldGetBodyCount(const NewtonWorld* const newtonWorld); +NEWTON_API int NewtonWorldGetConstraintCount(const NewtonWorld* const newtonWorld); + +// NEWTON_API int NewtonGetActiveBodiesCount(); +// NEWTON_API int NewtonGetActiveConstraintsCount(); +// NEWTON_API dFloat NewtonGetGlobalScale (const NewtonWorld* const newtonWorld); + + + +// ********************************************************************************************** +// +// Simulation islands +// +// ********************************************************************************************** +NEWTON_API NewtonBody* NewtonIslandGetBody (const void* const island, int bodyIndex); +NEWTON_API void NewtonIslandGetBodyAABB (const void* const island, int bodyIndex, dFloat* const p0, dFloat* const p1); + +// ********************************************************************************************** +// +// Physics Material Section +// +// ********************************************************************************************** +NEWTON_API int NewtonMaterialCreateGroupID(const NewtonWorld* const newtonWorld); +NEWTON_API int NewtonMaterialGetDefaultGroupID(const NewtonWorld* const newtonWorld); +NEWTON_API void NewtonMaterialDestroyAllGroupID(const NewtonWorld* const newtonWorld); + +// material definitions that can not be overwritten in function callback +NEWTON_API void* NewtonMaterialGetUserData (const NewtonWorld* const newtonWorld, int id0, int id1); +NEWTON_API void NewtonMaterialSetSurfaceThickness (const NewtonWorld* const newtonWorld, int id0, int id1, dFloat thickness); +NEWTON_API void NewtonMaterialSetContinuousCollisionMode (const NewtonWorld* const newtonWorld, int id0, int id1, int state); +NEWTON_API void NewtonMaterialSetCollisionCallback (const NewtonWorld* const newtonWorld, int id0, int id1, void* const userData, + NewtonOnAABBOverlap aabbOverlap, NewtonContactsProcess process); + +NEWTON_API void NewtonMaterialSetDefaultSoftness (const NewtonWorld* const newtonWorld, int id0, int id1, dFloat value); +NEWTON_API void NewtonMaterialSetDefaultElasticity (const NewtonWorld* const newtonWorld, int id0, int id1, dFloat elasticCoef); +NEWTON_API void NewtonMaterialSetDefaultCollidable (const NewtonWorld* const newtonWorld, int id0, int id1, int state); +NEWTON_API void NewtonMaterialSetDefaultFriction (const NewtonWorld* const newtonWorld, int id0, int id1, dFloat staticFriction, dFloat kineticFriction); + +NEWTON_API NewtonMaterial* NewtonWorldGetFirstMaterial (const NewtonWorld* const newtonWorld); +NEWTON_API NewtonMaterial* NewtonWorldGetNextMaterial (const NewtonWorld* const newtonWorld, const NewtonMaterial* const material); + +NEWTON_API NewtonBody* NewtonWorldGetFirstBody (const NewtonWorld* const newtonWorld); +NEWTON_API NewtonBody* NewtonWorldGetNextBody (const NewtonWorld* const newtonWorld, const NewtonBody* const curBody); + + +// ********************************************************************************************** +// +// Physics Contact control functions +// +// ********************************************************************************************** +NEWTON_API void *NewtonMaterialGetMaterialPairUserData (const NewtonMaterial* const material); +NEWTON_API unsigned NewtonMaterialGetContactFaceAttribute (const NewtonMaterial* const material); +NEWTON_API NewtonCollision* NewtonMaterialGetBodyCollidingShape (const NewtonMaterial* const material, const NewtonBody* const body); +//NEWTON_API unsigned NewtonMaterialGetBodyCollisionID (const NewtonMaterial* const material, const NewtonBody* const body); +NEWTON_API dFloat NewtonMaterialGetContactNormalSpeed (const NewtonMaterial* const material); +NEWTON_API void NewtonMaterialGetContactForce (const NewtonMaterial* const material, NewtonBody* const body, dFloat* const force); +NEWTON_API void NewtonMaterialGetContactPositionAndNormal (const NewtonMaterial* const material, NewtonBody* const body, dFloat* const posit, dFloat* const normal); +NEWTON_API void NewtonMaterialGetContactTangentDirections (const NewtonMaterial* const material, NewtonBody* const body, dFloat* const dir0, dFloat* const dir1); +NEWTON_API dFloat NewtonMaterialGetContactTangentSpeed (const NewtonMaterial* const material, int index); + +NEWTON_API void NewtonMaterialSetContactSoftness (const NewtonMaterial* const material, dFloat softness); +NEWTON_API void NewtonMaterialSetContactElasticity (const NewtonMaterial* const material, dFloat restitution); +NEWTON_API void NewtonMaterialSetContactFrictionState (const NewtonMaterial* const material, int state, int index); +NEWTON_API void NewtonMaterialSetContactFrictionCoef (const NewtonMaterial* const material, dFloat staticFrictionCoef, dFloat kineticFrictionCoef, int index); + +NEWTON_API void NewtonMaterialSetContactNormalAcceleration (const NewtonMaterial* const material, dFloat accel); +NEWTON_API void NewtonMaterialSetContactNormalDirection (const NewtonMaterial* const material, const dFloat* const directionVector); + +NEWTON_API void NewtonMaterialSetContactTangentAcceleration (const NewtonMaterial* const material, dFloat accel, int index); +NEWTON_API void NewtonMaterialContactRotateTangentDirections (const NewtonMaterial* const material, const dFloat* const directionVector); + + + +// ********************************************************************************************** +// +// convex collision primitives creation functions +// +// ********************************************************************************************** +NEWTON_API NewtonCollision* NewtonCreateNull (const NewtonWorld* const newtonWorld); +NEWTON_API NewtonCollision* NewtonCreateSphere (const NewtonWorld* const newtonWorld, dFloat radiusX, dFloat radiusY, dFloat radiusZ, int shapeID, const dFloat* const offsetMatrix); +NEWTON_API NewtonCollision* NewtonCreateBox (const NewtonWorld* const newtonWorld, dFloat dx, dFloat dy, dFloat dz, int shapeID, const dFloat* const offsetMatrix); +NEWTON_API NewtonCollision* NewtonCreateCone (const NewtonWorld* const newtonWorld, dFloat radius, dFloat height, int shapeID, const dFloat* const offsetMatrix); +NEWTON_API NewtonCollision* NewtonCreateCapsule (const NewtonWorld* const newtonWorld, dFloat radius, dFloat height, int shapeID, const dFloat* const offsetMatrix); +NEWTON_API NewtonCollision* NewtonCreateCylinder (const NewtonWorld* const newtonWorld, dFloat radius, dFloat height, int shapeID, const dFloat* const offsetMatrix); +NEWTON_API NewtonCollision* NewtonCreateChamferCylinder (const NewtonWorld* const newtonWorld, dFloat radius, dFloat height, int shapeID, const dFloat* const offsetMatrix); +NEWTON_API NewtonCollision* NewtonCreateConvexHull (const NewtonWorld* const newtonWorld, int count, const dFloat* const vertexCloud, int strideInBytes, dFloat tolerance, int shapeID, const dFloat* const offsetMatrix); +NEWTON_API NewtonCollision* NewtonCreateConvexHullFromMesh (const NewtonWorld* const newtonWorld, const NewtonMesh* const mesh, dFloat tolerance, int shapeID); + +NEWTON_API NewtonCollision* NewtonCreateConvexHullModifier (const NewtonWorld* const newtonWorld, const NewtonCollision* const convexHullCollision, int shapeID); +NEWTON_API void NewtonConvexHullModifierGetMatrix (const NewtonCollision* const convexHullCollision, dFloat* const matrix); +NEWTON_API void NewtonConvexHullModifierSetMatrix (const NewtonCollision* const convexHullCollision, const dFloat* const matrix); + +NEWTON_API int NewtonCollisionIsTriggerVolume(const NewtonCollision* const convexCollision); +NEWTON_API void NewtonCollisionSetAsTriggerVolume(const NewtonCollision* convexCollision, int trigger); + +NEWTON_API void NewtonCollisionSetMaxBreakImpactImpulse(const NewtonCollision* const convexHullCollision, dFloat maxImpactImpulse); +NEWTON_API dFloat NewtonCollisionGetMaxBreakImpactImpulse(const NewtonCollision* const convexHullCollision); + +NEWTON_API void NewtonCollisionSetUserID (const NewtonCollision* convexCollision, unsigned id); +NEWTON_API unsigned NewtonCollisionGetUserID (const NewtonCollision* const convexCollision); + +NEWTON_API int NewtonConvexHullGetFaceIndices (const NewtonCollision* const convexHullCollision, int face, int* const faceIndices); +NEWTON_API dFloat NewtonConvexCollisionCalculateVolume (const NewtonCollision* const convexCollision); +NEWTON_API void NewtonConvexCollisionCalculateInertialMatrix (const NewtonCollision* convexCollision, dFloat* const inertia, dFloat* const origin); + + +NEWTON_API void NewtonCollisionMakeUnique (const NewtonWorld* const newtonWorld, const NewtonCollision* const collision); +NEWTON_API void NewtonReleaseCollision (const NewtonWorld* const newtonWorld, const NewtonCollision* const collision); +NEWTON_API int NewtonAddCollisionReference (const NewtonCollision* const collision); + + +// ********************************************************************************************** +// +// mass/spring/damper collision shape +// +// ********************************************************************************************** +// NEWTON_API NewtonCollision* NewtonCreateSoftShape (const NewtonWorld* const newtonWorld); +// NEWTON_API void NewtonSoftBodySetMassCount (const NewtonCollision* convexCollision, int count); +// NEWTON_API void NewtonSoftBodySetSpringCount (const NewtonCollision* convexCollision, int count); + +// NEWTON_API void NewtonSoftBodySetMass (const NewtonCollision* convexCollision, int index, dFloat mass, dFloat* position); +// NEWTON_API int NewtonSoftBodySetSpring (const NewtonCollision* convexCollision, int index, int mass0, int mass1, dFloat stiffness, dFloat damper); +// NEWTON_API int NewtonSoftBodyGetMassArray (const NewtonCollision* convexCollision, dFloat* masses, dFloat** positions); + + +// ********************************************************************************************** +// +// complex collision primitives creation functions +// +// ********************************************************************************************** +NEWTON_API NewtonCollision* NewtonCreateCompoundCollision (const NewtonWorld* const newtonWorld, int count, NewtonCollision* const collisionPrimitiveArray[], int shapeID); +NEWTON_API NewtonCollision* NewtonCreateCompoundCollisionFromMesh (const NewtonWorld* const newtonWorld, const NewtonMesh* const mesh, dFloat hullTolerance, int shapeID, int subShapeID); +//NEWTON_API NewtonCollision* NewtonCreateCompoundCollisionFromMesh(const NewtonWorld* const newtonWorld, const NewtonMesh* const mesh, int maxSubShapesCount, int shapeID, int subShapeID); + +// ********************************************************************************************** +// +// complex breakable collision primitives interface +// +// ********************************************************************************************** +// NEWTON_API NewtonCollision* NewtonCreateCompoundBreakable (const NewtonWorld* const newtonWorld, int meshCount, +// NewtonMesh* const solids[], NewtonMesh* const splitePlanes[], +// dFloat* const matrixPallete, int* const shapeIDArray, dFloat* const densities, +// int shapeID, int debriID, NewtonCollisionCompoundBreakableCallback callback, void* buildUsedData); + +NEWTON_API NewtonCollision* NewtonCreateCompoundBreakable (const NewtonWorld* const newtonWorld, int meshCount, + const NewtonMesh** const solids, const int* const shapeIDArray, + const dFloat* const densities, const int* const internalFaceMaterial, + int shapeID, int debriID, dFloat debriSeparationGap); + + +NEWTON_API void NewtonCompoundBreakableResetAnchoredPieces (const NewtonCollision* const compoundBreakable); +NEWTON_API void NewtonCompoundBreakableSetAnchoredPieces (const NewtonCollision* const compoundBreakable, int fixShapesCount, dFloat* const matrixPallete, NewtonCollision** const fixedShapesArray); + +NEWTON_API int NewtonCompoundBreakableGetVertexCount (const NewtonCollision* const compoundBreakable); +NEWTON_API void NewtonCompoundBreakableGetVertexStreams (const NewtonCollision* const compoundBreakable, int vertexStrideInByte, dFloat* const vertex, + int normalStrideInByte, dFloat* const normal, int uvStrideInByte, dFloat* const uv); + + +NEWTON_API NewtonbreakableComponentMesh* NewtonBreakableGetMainMesh (const NewtonCollision* const compoundBreakable); +NEWTON_API NewtonbreakableComponentMesh* NewtonBreakableGetFirstComponent (const NewtonCollision* const compoundBreakable); +NEWTON_API NewtonbreakableComponentMesh* NewtonBreakableGetNextComponent (const NewtonbreakableComponentMesh* const component); + +NEWTON_API void NewtonBreakableBeginDelete (const NewtonCollision* const compoundBreakable); +NEWTON_API NewtonBody* NewtonBreakableCreateDebrieBody (const NewtonCollision* const compoundBreakable, const NewtonbreakableComponentMesh* const component); +NEWTON_API void NewtonBreakableDeleteComponent (const NewtonCollision* const compoundBreakable, const NewtonbreakableComponentMesh* const component); +NEWTON_API void NewtonBreakableEndDelete (const NewtonCollision* const compoundBreakable); + + +NEWTON_API int NewtonBreakableGetComponentsInRadius (const NewtonCollision* const compoundBreakable, const dFloat* position, dFloat radius, NewtonbreakableComponentMesh** const segments, int maxCount); + +NEWTON_API void* NewtonBreakableGetFirstSegment (const NewtonbreakableComponentMesh* const breakableComponent); +NEWTON_API void* NewtonBreakableGetNextSegment (const void* const segment); + +NEWTON_API int NewtonBreakableSegmentGetMaterial (const void* const segment); +NEWTON_API int NewtonBreakableSegmentGetIndexCount (const void* const segment); +NEWTON_API int NewtonBreakableSegmentGetIndexStream (const NewtonCollision* const compoundBreakable, const NewtonbreakableComponentMesh* const meshOwner, const void* const segment, int* const index); +NEWTON_API int NewtonBreakableSegmentGetIndexStreamShort (const NewtonCollision* const compoundBreakable, const NewtonbreakableComponentMesh* const meshOwner, const void* const segment, short int* const index); + + +NEWTON_API NewtonCollision* NewtonCreateUserMeshCollision (const NewtonWorld* const newtonWorld, const dFloat* const minBox, + const dFloat* const maxBox, void* const userData, NewtonUserMeshCollisionCollideCallback collideCallback, + NewtonUserMeshCollisionRayHitCallback rayHitCallback, NewtonUserMeshCollisionDestroyCallback destroyCallback, + NewtonUserMeshCollisionGetCollisionInfo getInfoCallback, NewtonUserMeshCollisionGetFacesInAABB facesInAABBCallback, int shapeID); + + +NEWTON_API NewtonCollision* NewtonCreateSceneCollision (const NewtonWorld* const newtonWorld, int shapeID); +NEWTON_API NewtonSceneProxy* NewtonSceneCollisionCreateProxy (NewtonCollision* const scene, NewtonCollision* const collision, const dFloat* const matrix); + +NEWTON_API void NewtonSceneCollisionDestroyProxy (NewtonCollision* const scene, NewtonSceneProxy* Proxy); +NEWTON_API void NewtonSceneProxySetMatrix (NewtonSceneProxy* const proxy, const dFloat* matrix); +NEWTON_API void NewtonSceneProxyGetMatrix (NewtonSceneProxy* const proxy, dFloat* matrix); +NEWTON_API void NewtonSceneSetProxyUserData (NewtonSceneProxy* const proxy, void* userData); +NEWTON_API void* NewtonSceneGetProxyUserData (NewtonSceneProxy* const proxy); + +NEWTON_API NewtonSceneProxy* NewtonSceneGetFirstProxy (NewtonCollision* const scene); +NEWTON_API NewtonSceneProxy* NewtonSceneGetNextProxy (NewtonCollision* const scene, NewtonSceneProxy* const proxy); + +NEWTON_API void NewtonSceneCollisionOptimize (NewtonCollision* scene); + +// *********************************************************************************************************** +// +// Collision serialization functions +// +// *********************************************************************************************************** +NEWTON_API NewtonCollision* NewtonCreateCollisionFromSerialization (const NewtonWorld* const newtonWorld, NewtonDeserialize deserializeFunction, void* const serializeHandle); +NEWTON_API void NewtonCollisionSerialize (const NewtonWorld* const newtonWorld, const NewtonCollision* const collision, NewtonSerialize serializeFunction, void* const serializeHandle); +NEWTON_API void NewtonCollisionGetInfo (const NewtonCollision* const collision, NewtonCollisionInfoRecord* const collisionInfo); + +// ********************************************************************************************** +// +// Static collision shapes functions +// +// ********************************************************************************************** +NEWTON_API NewtonCollision* NewtonCreateHeightFieldCollision (const NewtonWorld* const newtonWorld, int width, int height, int gridsDiagonals, + const unsigned short* const elevationMap, const char* const attributeMap, + dFloat horizontalScale, dFloat verticalScale, int shapeID); +NEWTON_API void NewtonHeightFieldSetUserRayCastCallback (const NewtonCollision* const treeCollision, NewtonHeightFieldRayCastCallback rayHitCallback); + + +NEWTON_API NewtonCollision* NewtonCreateTreeCollision (const NewtonWorld* const newtonWorld, int shapeID); +NEWTON_API NewtonCollision* NewtonCreateTreeCollisionFromMesh (const NewtonWorld* const newtonWorld, const NewtonMesh* const mesh, int shapeID); + +NEWTON_API void NewtonTreeCollisionSetUserRayCastCallback (const NewtonCollision* const treeCollision, NewtonCollisionTreeRayCastCallback rayHitCallback); + +NEWTON_API void NewtonTreeCollisionBeginBuild (const NewtonCollision* treeCollision); +NEWTON_API void NewtonTreeCollisionAddFace (const NewtonCollision* const treeCollision, int vertexCount, const dFloat* const vertexPtr, int strideInBytes, int faceAttribute); +NEWTON_API void NewtonTreeCollisionEndBuild (const NewtonCollision* const treeCollision, int optimize); + +NEWTON_API int NewtonTreeCollisionGetFaceAtribute (const NewtonCollision* const treeCollision, const int* const faceIndexArray); +NEWTON_API void NewtonTreeCollisionSetFaceAtribute (const NewtonCollision* const treeCollision, const int* const faceIndexArray, int attribute); +NEWTON_API int NewtonTreeCollisionGetVertexListIndexListInAABB (const NewtonCollision* const treeCollision, const dFloat* const p0, const dFloat* const p1, const dFloat** const vertexArray, int* const vertexCount, int* const vertexStrideInBytes, const int* const indexList, int maxIndexCount, const int* const faceAttribute); + + +NEWTON_API void NewtonStaticCollisionSetDebugCallback (const NewtonCollision* const staticCollision, NewtonTreeCollisionCallback userCallback); + +// ********************************************************************************************** +// +// General purpose collision library functions +// +// ********************************************************************************************** +NEWTON_API int NewtonCollisionPointDistance (const NewtonWorld* const newtonWorld, const dFloat* const point, + const NewtonCollision* const collision, const dFloat* const matrix, dFloat* const contact, dFloat* const normal, int threadIndex); + +NEWTON_API int NewtonCollisionClosestPoint (const NewtonWorld* const newtonWorld, + const NewtonCollision* const collisionA, const dFloat* const matrixA, const NewtonCollision* const collisionB, const dFloat* const matrixB, + dFloat* const contactA, dFloat* const contactB, dFloat* const normalAB, int threadIndex); + +NEWTON_API int NewtonCollisionCollide (const NewtonWorld* const newtonWorld, int maxSize, + const NewtonCollision* const collisionA, const dFloat* const matrixA, + const NewtonCollision* const collisionB, const dFloat* const matrixB, + dFloat* const contacts, dFloat* const normals, dFloat* const penetration, int threadIndex); + +NEWTON_API int NewtonCollisionCollideContinue (const NewtonWorld* const newtonWorld, int maxSize, const dFloat timestep, + const NewtonCollision* const collisionA, const dFloat* const matrixA, const dFloat* const velocA, const dFloat* omegaA, + const NewtonCollision* const collisionB, const dFloat* const matrixB, const dFloat* const velocB, const dFloat* const omegaB, + dFloat* const timeOfImpact, dFloat* const contacts, dFloat* const normals, dFloat* const penetration, int threadIndex); + +NEWTON_API void NewtonCollisionSupportVertex (const NewtonCollision* const collision, const dFloat* const dir, dFloat* const vertex); +NEWTON_API dFloat NewtonCollisionRayCast (const NewtonCollision* const collision, const dFloat* const p0, const dFloat* const p1, dFloat* const normal, int* const attribute); +NEWTON_API void NewtonCollisionCalculateAABB (const NewtonCollision* const collision, const dFloat* const matrix, dFloat* const p0, dFloat* const p1); +NEWTON_API void NewtonCollisionForEachPolygonDo (const NewtonCollision* const collision, const dFloat* const matrix, NewtonCollisionIterator callback, void* const userData); + + +// ********************************************************************************************** +// +// transforms utility functions +// +// ********************************************************************************************** +NEWTON_API void NewtonGetEulerAngle (const dFloat* const matrix, dFloat* const eulersAngles); +NEWTON_API void NewtonSetEulerAngle (const dFloat* const eulersAngles, dFloat* const matrix); +NEWTON_API dFloat NewtonCalculateSpringDamperAcceleration (dFloat dt, dFloat ks, dFloat x, dFloat kd, dFloat s); + +// ********************************************************************************************** +// +// body manipulation functions +// +// ********************************************************************************************** +NEWTON_API NewtonBody* NewtonCreateBody (const NewtonWorld* const newtonWorld, const NewtonCollision* const collision, const dFloat* const matrix); +NEWTON_API void NewtonDestroyBody(const NewtonWorld* const newtonWorld, const NewtonBody* const body); + +NEWTON_API void NewtonBodyAddForce (const NewtonBody* const body, const dFloat* const force); +NEWTON_API void NewtonBodyAddTorque (const NewtonBody* const body, const dFloat* const torque); +NEWTON_API void NewtonBodyCalculateInverseDynamicsForce (const NewtonBody* const body, dFloat timestep, const dFloat* const desiredVeloc, dFloat* const forceOut); + +NEWTON_API void NewtonBodySetMatrix (const NewtonBody* const body, const dFloat* const matrix); +NEWTON_API void NewtonBodySetMatrixRecursive (const NewtonBody* const body, const dFloat* const matrix); +NEWTON_API void NewtonBodySetMassMatrix (const NewtonBody* const body, dFloat mass, dFloat Ixx, dFloat Iyy, dFloat Izz); +NEWTON_API void NewtonBodySetMaterialGroupID (const NewtonBody* const body, int id); +NEWTON_API void NewtonBodySetContinuousCollisionMode (const NewtonBody* const body, unsigned state); +NEWTON_API void NewtonBodySetJointRecursiveCollision (const NewtonBody* const body, unsigned state); +NEWTON_API void NewtonBodySetOmega (const NewtonBody* const body, const dFloat* const omega); +NEWTON_API void NewtonBodySetVelocity (const NewtonBody* const body, const dFloat* const velocity); +NEWTON_API void NewtonBodySetForce (const NewtonBody* const body, const dFloat* const force); +NEWTON_API void NewtonBodySetTorque (const NewtonBody* const body, const dFloat* const torque); + +NEWTON_API void NewtonBodySetCentreOfMass (const NewtonBody* const body, const dFloat* const com); +NEWTON_API void NewtonBodySetLinearDamping (const NewtonBody* const body, dFloat linearDamp); +NEWTON_API void NewtonBodySetAngularDamping (const NewtonBody* const body, const dFloat* const angularDamp); +NEWTON_API void NewtonBodySetUserData (const NewtonBody* const body, void* const userData); +NEWTON_API void NewtonBodySetCollision (const NewtonBody* const body, const NewtonCollision* const collision); + + + +NEWTON_API int NewtonBodyGetSleepState (const NewtonBody* const body); +NEWTON_API int NewtonBodyGetAutoSleep (const NewtonBody* const body); +NEWTON_API void NewtonBodySetAutoSleep (const NewtonBody* const body, int state); + +NEWTON_API int NewtonBodyGetFreezeState(const NewtonBody* const body); +NEWTON_API void NewtonBodySetFreezeState (const NewtonBody* const body, int state); + + +// NEWTON_API void NewtonBodySetAutoFreeze(const NewtonBody* const body, int state); +// NEWTON_API void NewtonBodyCoriolisForcesMode (const NewtonBody* const body, int mode); +// NEWTON_API void NewtonBodySetGyroscopicForcesMode (const NewtonBody* const body, int mode); +// NEWTON_API int NewtonBodyGetGyroscopicForcesMode (const NewtonBody* const body); +// NEWTON_API int NewtonBodyGetFreezeState (const NewtonBody* const body); +// NEWTON_API void NewtonBodySetFreezeState (const NewtonBody* const body, int state); +// NEWTON_API void NewtonBodyGetFreezeTreshold (const NewtonBody* const body, dFloat* freezeSpeed2, dFloat* freezeOmega2); +// NEWTON_API void NewtonBodySetFreezeTreshold (const NewtonBody* const body, dFloat freezeSpeed2, dFloat freezeOmega2, int framesCount); +// NEWTON_API void NewtonBodySetAutoactiveCallback (const NewtonBody* const body, NewtonBodyActivationState callback); + + +NEWTON_API void NewtonBodySetDestructorCallback (const NewtonBody* const body, NewtonBodyDestructor callback); + +NEWTON_API void NewtonBodySetTransformCallback (const NewtonBody* const body, NewtonSetTransform callback); +NEWTON_API NewtonSetTransform NewtonBodyGetTransformCallback (const NewtonBody* const body); + +NEWTON_API void NewtonBodySetForceAndTorqueCallback (const NewtonBody* const body, NewtonApplyForceAndTorque callback); +NEWTON_API NewtonApplyForceAndTorque NewtonBodyGetForceAndTorqueCallback (const NewtonBody* const body); +NEWTON_API void* NewtonBodyGetUserData (const NewtonBody* const body); +NEWTON_API NewtonWorld* NewtonBodyGetWorld (const NewtonBody* const body); +NEWTON_API NewtonCollision* NewtonBodyGetCollision (const NewtonBody* const body); +NEWTON_API int NewtonBodyGetMaterialGroupID (const NewtonBody* const body); + +NEWTON_API int NewtonBodyGetContinuousCollisionMode (const NewtonBody* const body); +NEWTON_API int NewtonBodyGetJointRecursiveCollision (const NewtonBody* const body); + +NEWTON_API void NewtonBodyGetMatrix(const NewtonBody* const body, dFloat* const matrix); +NEWTON_API void NewtonBodyGetRotation(const NewtonBody* const body, dFloat* const rotation); +NEWTON_API void NewtonBodyGetMassMatrix (const NewtonBody* const body, dFloat* mass, dFloat* const Ixx, dFloat* const Iyy, dFloat* const Izz); +NEWTON_API void NewtonBodyGetInvMass(const NewtonBody* const body, dFloat* const invMass, dFloat* const invIxx, dFloat* const invIyy, dFloat* const invIzz); +NEWTON_API void NewtonBodyGetOmega(const NewtonBody* const body, dFloat* const vector); +NEWTON_API void NewtonBodyGetVelocity(const NewtonBody* const body, dFloat* const vector); +NEWTON_API void NewtonBodyGetForce(const NewtonBody* const body, dFloat* const vector); +NEWTON_API void NewtonBodyGetTorque(const NewtonBody* const body, dFloat* const vector); +NEWTON_API void NewtonBodyGetForceAcc(const NewtonBody* const body, dFloat* const vector); +NEWTON_API void NewtonBodyGetTorqueAcc(const NewtonBody* const body, dFloat* const vector); +NEWTON_API void NewtonBodyGetCentreOfMass (const NewtonBody* const body, dFloat* const com); + +NEWTON_API dFloat NewtonBodyGetLinearDamping (const NewtonBody* const body); +NEWTON_API void NewtonBodyGetAngularDamping (const NewtonBody* const body, dFloat* const vector); +NEWTON_API void NewtonBodyGetAABB (const NewtonBody* const body, dFloat* const p0, dFloat* const p1); +NEWTON_API NewtonJoint* NewtonBodyGetFirstJoint (const NewtonBody* const body); +NEWTON_API NewtonJoint* NewtonBodyGetNextJoint (const NewtonBody* const body, const NewtonJoint* const joint); +NEWTON_API NewtonJoint* NewtonBodyGetFirstContactJoint (const NewtonBody* const body); +NEWTON_API NewtonJoint* NewtonBodyGetNextContactJoint (const NewtonBody* const body, const NewtonJoint* const contactJoint); + +NEWTON_API void* NewtonContactJointGetFirstContact (const NewtonJoint* const contactJoint); +NEWTON_API void* NewtonContactJointGetNextContact (const NewtonJoint* const contactJoint, void* const contact); + +NEWTON_API int NewtonContactJointGetContactCount(const NewtonJoint* const contactJoint); +NEWTON_API void NewtonContactJointRemoveContact(const NewtonJoint* const contactJoint, void* const contact); + +NEWTON_API NewtonMaterial* NewtonContactGetMaterial (const void* const contact); + + +NEWTON_API void NewtonBodyAddBuoyancyForce (const NewtonBody* const body, dFloat fluidDensity, + dFloat fluidLinearViscosity, dFloat fluidAngularViscosity, + const dFloat* const gravityVector, NewtonGetBuoyancyPlane buoyancyPlane, void* const context); + +// NEWTON_API void NewtonBodyForEachPolygonDo (const NewtonBody* const body, NewtonCollisionIterator callback); +NEWTON_API void NewtonBodyAddImpulse (const NewtonBody* const body, const dFloat* const pointDeltaVeloc, const dFloat* const pointPosit); + + +NEWTON_API void NewtonBodyApplyImpulseArray (const NewtonBody* const body, int impuleCount, int strideInByte, const dFloat* const impulseArray, const dFloat* const pointArray); + + +// ********************************************************************************************** +// +// Common joint functions +// +// ********************************************************************************************** +NEWTON_API void* NewtonJointGetUserData (const NewtonJoint* const joint); +NEWTON_API void NewtonJointSetUserData (const NewtonJoint* const joint, void* const userData); + +NEWTON_API NewtonBody* NewtonJointGetBody0 (const NewtonJoint* const joint); +NEWTON_API NewtonBody* NewtonJointGetBody1 (const NewtonJoint* const joint); + +NEWTON_API void NewtonJointGetInfo (const NewtonJoint* const joint, NewtonJointRecord* const info); +NEWTON_API int NewtonJointGetCollisionState (const NewtonJoint* const joint); +NEWTON_API void NewtonJointSetCollisionState (const NewtonJoint* const joint, int state); + +NEWTON_API dFloat NewtonJointGetStiffness (const NewtonJoint* const joint); +NEWTON_API void NewtonJointSetStiffness (const NewtonJoint* const joint, dFloat state); + +NEWTON_API void NewtonDestroyJoint(const NewtonWorld* const newtonWorld, const NewtonJoint* const joint); +NEWTON_API void NewtonJointSetDestructor (const NewtonJoint* const joint, NewtonConstraintDestructor destructor); + + + + +// ********************************************************************************************** +// +// Ball and Socket joint functions +// +// ********************************************************************************************** +NEWTON_API NewtonJoint* NewtonConstraintCreateBall (const NewtonWorld* const newtonWorld, const dFloat* pivotPoint, + const NewtonBody* const childBody, const NewtonBody* const parentBody); +NEWTON_API void NewtonBallSetUserCallback (const NewtonJoint* const ball, NewtonBallCallBack callback); +NEWTON_API void NewtonBallGetJointAngle (const NewtonJoint* const ball, dFloat* angle); +NEWTON_API void NewtonBallGetJointOmega (const NewtonJoint* const ball, dFloat* omega); +NEWTON_API void NewtonBallGetJointForce (const NewtonJoint* const ball, dFloat* const force); +NEWTON_API void NewtonBallSetConeLimits (const NewtonJoint* const ball, const dFloat* pin, dFloat maxConeAngle, dFloat maxTwistAngle); + +// ********************************************************************************************** +// +// Hinge joint functions +// +// ********************************************************************************************** +NEWTON_API NewtonJoint* NewtonConstraintCreateHinge (const NewtonWorld* const newtonWorld, + const dFloat* pivotPoint, const dFloat* pinDir, + const NewtonBody* const childBody, const NewtonBody* const parentBody); + +NEWTON_API void NewtonHingeSetUserCallback (const NewtonJoint* const hinge, NewtonHingeCallBack callback); +NEWTON_API dFloat NewtonHingeGetJointAngle (const NewtonJoint* const hinge); +NEWTON_API dFloat NewtonHingeGetJointOmega (const NewtonJoint* const hinge); +NEWTON_API void NewtonHingeGetJointForce (const NewtonJoint* const hinge, dFloat* const force); +NEWTON_API dFloat NewtonHingeCalculateStopAlpha (const NewtonJoint* const hinge, const NewtonHingeSliderUpdateDesc* const desc, dFloat angle); + +// ********************************************************************************************** +// +// Slider joint functions +// +// ********************************************************************************************** +NEWTON_API NewtonJoint* NewtonConstraintCreateSlider (const NewtonWorld* const newtonWorld, + const dFloat* pivotPoint, const dFloat* pinDir, + const NewtonBody* const childBody, const NewtonBody* const parentBody); +NEWTON_API void NewtonSliderSetUserCallback (const NewtonJoint* const slider, NewtonSliderCallBack callback); +NEWTON_API dFloat NewtonSliderGetJointPosit (const NewtonJoint* slider); +NEWTON_API dFloat NewtonSliderGetJointVeloc (const NewtonJoint* slider); +NEWTON_API void NewtonSliderGetJointForce (const NewtonJoint* const slider, dFloat* const force); +NEWTON_API dFloat NewtonSliderCalculateStopAccel (const NewtonJoint* const slider, const NewtonHingeSliderUpdateDesc* const desc, dFloat position); + + +// ********************************************************************************************** +// +// Corkscrew joint functions +// +// ********************************************************************************************** +NEWTON_API NewtonJoint* NewtonConstraintCreateCorkscrew (const NewtonWorld* const newtonWorld, + const dFloat* pivotPoint, const dFloat* pinDir, + const NewtonBody* const childBody, const NewtonBody* const parentBody); +NEWTON_API void NewtonCorkscrewSetUserCallback (const NewtonJoint* const corkscrew, NewtonCorkscrewCallBack callback); +NEWTON_API dFloat NewtonCorkscrewGetJointPosit (const NewtonJoint* const corkscrew); +NEWTON_API dFloat NewtonCorkscrewGetJointAngle (const NewtonJoint* const corkscrew); +NEWTON_API dFloat NewtonCorkscrewGetJointVeloc (const NewtonJoint* const corkscrew); +NEWTON_API dFloat NewtonCorkscrewGetJointOmega (const NewtonJoint* const corkscrew); +NEWTON_API void NewtonCorkscrewGetJointForce (const NewtonJoint* const corkscrew, dFloat* const force); +NEWTON_API dFloat NewtonCorkscrewCalculateStopAlpha (const NewtonJoint* const corkscrew, const NewtonHingeSliderUpdateDesc* const desc, dFloat angle); +NEWTON_API dFloat NewtonCorkscrewCalculateStopAccel (const NewtonJoint* const corkscrew, const NewtonHingeSliderUpdateDesc* const desc, dFloat position); + + +// ********************************************************************************************** +// +// Universal joint functions +// +// ********************************************************************************************** +NEWTON_API NewtonJoint* NewtonConstraintCreateUniversal (const NewtonWorld* const newtonWorld, + const dFloat* pivotPoint, const dFloat* pinDir0, const dFloat* pinDir1, + const NewtonBody* const childBody, const NewtonBody* const parentBody); +NEWTON_API void NewtonUniversalSetUserCallback (const NewtonJoint* const universal, NewtonUniversalCallBack callback); +NEWTON_API dFloat NewtonUniversalGetJointAngle0 (const NewtonJoint* const universal); +NEWTON_API dFloat NewtonUniversalGetJointAngle1 (const NewtonJoint* const universal); +NEWTON_API dFloat NewtonUniversalGetJointOmega0 (const NewtonJoint* const universal); +NEWTON_API dFloat NewtonUniversalGetJointOmega1 (const NewtonJoint* const universal); +NEWTON_API void NewtonUniversalGetJointForce (const NewtonJoint* const universal, dFloat* const force); +NEWTON_API dFloat NewtonUniversalCalculateStopAlpha0 (const NewtonJoint* const universal, const NewtonHingeSliderUpdateDesc* const desc, dFloat angle); +NEWTON_API dFloat NewtonUniversalCalculateStopAlpha1 (const NewtonJoint* const universal, const NewtonHingeSliderUpdateDesc* const desc, dFloat angle); + + +// ********************************************************************************************** +// +// Up vector joint functions +// +// ********************************************************************************************** +NEWTON_API NewtonJoint* NewtonConstraintCreateUpVector (const NewtonWorld* const newtonWorld, const dFloat* pinDir, const NewtonBody* const body); +NEWTON_API void NewtonUpVectorGetPin (const NewtonJoint* const upVector, dFloat *pin); +NEWTON_API void NewtonUpVectorSetPin (const NewtonJoint* const upVector, const dFloat *pin); + + +// ********************************************************************************************** +// +// User defined bilateral Joint +// +// ********************************************************************************************** +NEWTON_API NewtonJoint* NewtonConstraintCreateUserJoint (const NewtonWorld* const newtonWorld, int maxDOF, + NewtonUserBilateralCallBack callback, + NewtonUserBilateralGetInfoCallBack getInfo, + const NewtonBody* const childBody, const NewtonBody* const parentBody) ; +NEWTON_API void NewtonUserJointSetFeedbackCollectorCallback (const NewtonJoint* const joint, NewtonUserBilateralCallBack getFeedback); +NEWTON_API void NewtonUserJointAddLinearRow (const NewtonJoint* const joint, const dFloat* const pivot0, const dFloat* const pivot1, const dFloat* const dir); +NEWTON_API void NewtonUserJointAddAngularRow (const NewtonJoint* const joint, dFloat relativeAngle, const dFloat* const dir); +NEWTON_API void NewtonUserJointAddGeneralRow (const NewtonJoint* const joint, const dFloat* const jacobian0, const dFloat* const jacobian1); +NEWTON_API void NewtonUserJointSetRowMinimumFriction (const NewtonJoint* const joint, dFloat friction); +NEWTON_API void NewtonUserJointSetRowMaximumFriction (const NewtonJoint* const joint, dFloat friction); +NEWTON_API void NewtonUserJointSetRowAcceleration (const NewtonJoint* const joint, dFloat acceleration); +NEWTON_API void NewtonUserJointSetRowSpringDamperAcceleration (const NewtonJoint* const joint, dFloat springK, dFloat springD); +NEWTON_API void NewtonUserJointSetRowStiffness (const NewtonJoint* const joint, dFloat stiffness); +NEWTON_API dFloat NewtonUserJointGetRowForce (const NewtonJoint* const joint, int row); + + +// ********************************************************************************************** +// +// Mesh joint functions +// +// ********************************************************************************************** +NEWTON_API NewtonMesh* NewtonMeshCreate(const NewtonWorld* const newtonWorld); +NEWTON_API NewtonMesh* NewtonMeshCreateFromMesh(const NewtonMesh* const mesh); +NEWTON_API NewtonMesh* NewtonMeshCreateFromCollision(const NewtonCollision* const collision); +NEWTON_API NewtonMesh* NewtonMeshConvexHull (const NewtonWorld* const newtonWorld, int count, const dFloat* const vertexCloud, int strideInBytes, dFloat tolerance); +NEWTON_API NewtonMesh* NewtonMeshCreatePlane (const NewtonWorld* const newtonWorld, const dFloat* const locationMatrix, dFloat witdth, dFloat breadth, int material, const dFloat* const textureMatrix0, const dFloat* const textureMatrix1); + +NEWTON_API void NewtonMeshDestroy(const NewtonMesh* const mesh); + + NEWTON_API void NewtonMesApplyTransform (const NewtonMesh* const mesh, const dFloat* const matrix); +NEWTON_API void NewtonMeshCalculateOOBB(const NewtonMesh* const mesh, dFloat* const matrix, dFloat* const x, dFloat* const y, dFloat* const z); + +NEWTON_API void NewtonMeshCalculateVertexNormals(const NewtonMesh* const mesh, dFloat angleInRadians); +NEWTON_API void NewtonMeshApplySphericalMapping(const NewtonMesh* const mesh, int material); +NEWTON_API void NewtonMeshApplyBoxMapping(const NewtonMesh* const mesh, int front, int side, int top); +NEWTON_API void NewtonMeshApplyCylindricalMapping(const NewtonMesh* const mesh, int cylinderMaterial, int capMaterial); + +NEWTON_API int NewtonMeshIsOpenMesh (const NewtonMesh* const mesh); +NEWTON_API void NewtonMeshFixTJoints (const NewtonMesh* const mesh); + + +NEWTON_API void NewtonMeshPolygonize (const NewtonMesh* const mesh); +NEWTON_API void NewtonMeshTriangulate (const NewtonMesh* const mesh); +NEWTON_API NewtonMesh* NewtonMeshUnion (const NewtonMesh* const mesh, const NewtonMesh* const clipper, const dFloat* const clipperMatrix); +NEWTON_API NewtonMesh* NewtonMeshDifference (const NewtonMesh* const mesh, const NewtonMesh* const clipper, const dFloat* const clipperMatrix); +NEWTON_API NewtonMesh* NewtonMeshIntersection (const NewtonMesh* const mesh, const NewtonMesh* const clipper, const dFloat* const clipperMatrix); +NEWTON_API void NewtonMeshClip (const NewtonMesh* const mesh, const NewtonMesh* const clipper, const dFloat* const clipperMatrix, NewtonMesh** const topMesh, NewtonMesh** const bottomMesh); +NEWTON_API void NewtonMeshPlaneClip (const NewtonMesh* const mesh, dFloat* const planeMatrix, const dFloat* const planeTextureMatrix, int planeMaterial, NewtonMesh** const topMesh, NewtonMesh** const bottomMesh); + +NEWTON_API NewtonMesh* NewtonMeshApproximateConvexDecomposition (const NewtonMesh* const mesh, dFloat maxConcavity, int maxCount); +NEWTON_API NewtonMesh* NewtonMeshTetrahedralization (const NewtonMesh* const mesh, int internalMaterial, const dFloat* const textureMatrix); +NEWTON_API NewtonMesh* NewtonMeshVoronoiDecomposition (const NewtonMesh* const mesh, int pointCount, int pointStrideInBytes, const dFloat* const pointCloud, int internalMaterial, const dFloat* const textureMatrix); + + +NEWTON_API void NewtonRemoveUnusedVertices(const NewtonMesh* const mesh, int* const vertexRemapTable); + +NEWTON_API void NewtonMeshBeginFace(const NewtonMesh* const mesh); +NEWTON_API void NewtonMeshAddFace(const NewtonMesh* const mesh, int vertexCount, const dFloat* const vertex, int strideInBytes, int materialIndex); +NEWTON_API void NewtonMeshEndFace(const NewtonMesh* const mesh); + +NEWTON_API void NewtonMeshBuildFromVertexListIndexList(const NewtonMesh* const mesh, + int faceCount, const int* const faceIndexCount, const int* const faceMaterialIndex, + const dFloat* const vertex, int vertexStrideInBytes, const int* const vertexIndex, + const dFloat* const normal, int normalStrideInBytes, const int* const normalIndex, + const dFloat* const uv0, int uv0StrideInBytes, const int* const uv0Index, + const dFloat* const uv1, int uv1StrideInBytes, const int* const uv1Index); + + + +NEWTON_API void NewtonMeshGetVertexStreams (const NewtonMesh* const mesh, + int vertexStrideInByte, dFloat* const vertex, + int normalStrideInByte, dFloat* const normal, + int uvStrideInByte0, dFloat* const uv0, + int uvStrideInByte1, dFloat* const uv1); +NEWTON_API void NewtonMeshGetIndirectVertexStreams(const NewtonMesh* const mesh, + int vertexStrideInByte, dFloat* const vertex, int* const vertexIndices, int* const vertexCount, + int normalStrideInByte, dFloat* const normal, int* const normalIndices, int* const normalCount, + int uvStrideInByte0, dFloat* const uv0, int* const uvIndices0, int* const uvCount0, + int uvStrideInByte1, dFloat* const uv1, int* const uvIndices1, int* const uvCount1); +NEWTON_API void* NewtonMeshBeginHandle (const NewtonMesh* const mesh); +NEWTON_API void NewtonMeshEndHandle (const NewtonMesh* const mesh, void* const handle); +NEWTON_API int NewtonMeshFirstMaterial (const NewtonMesh* const mesh, void* const handle); +NEWTON_API int NewtonMeshNextMaterial (const NewtonMesh* const mesh, void* const handle, int materialId); +NEWTON_API int NewtonMeshMaterialGetMaterial (const NewtonMesh* const mesh, void* const handle, int materialId); +NEWTON_API int NewtonMeshMaterialGetIndexCount (const NewtonMesh* const mesh, void* const handle, int materialId); +NEWTON_API void NewtonMeshMaterialGetIndexStream (const NewtonMesh* const mesh, void* const handle, int materialId, int* const index); +NEWTON_API void NewtonMeshMaterialGetIndexStreamShort (const NewtonMesh* const mesh, void* const handle, int materialId, short int* const index); + +NEWTON_API NewtonMesh* NewtonMeshCreateFirstSingleSegment (const NewtonMesh* const mesh); +NEWTON_API NewtonMesh* NewtonMeshCreateNextSingleSegment (const NewtonMesh* const mesh, const NewtonMesh* const segment); + +NEWTON_API NewtonMesh* NewtonMeshCreateFirstLayer (const NewtonMesh* const mesh); +NEWTON_API NewtonMesh* NewtonMeshCreateNextLayer (const NewtonMesh* const mesh, const NewtonMesh* const segment); + + +NEWTON_API int NewtonMeshGetTotalFaceCount (const NewtonMesh* const mesh); +NEWTON_API int NewtonMeshGetTotalIndexCount (const NewtonMesh* const mesh); +NEWTON_API void NewtonMeshGetFaces (const NewtonMesh* const mesh, int* const faceIndexCount, int* const faceMaterial, void** const faceIndices); + + +NEWTON_API int NewtonMeshGetPointCount (const NewtonMesh* const mesh); +NEWTON_API int NewtonMeshGetPointStrideInByte (const NewtonMesh* const mesh); +NEWTON_API dFloat64* NewtonMeshGetPointArray (const NewtonMesh* const mesh); +NEWTON_API dFloat64* NewtonMeshGetNormalArray (const NewtonMesh* const mesh); +NEWTON_API dFloat64* NewtonMeshGetUV0Array (const NewtonMesh* const mesh); +NEWTON_API dFloat64* NewtonMeshGetUV1Array (const NewtonMesh* const mesh); + +NEWTON_API int NewtonMeshGetVertexCount (const NewtonMesh* const mesh); +NEWTON_API int NewtonMeshGetVertexStrideInByte (const NewtonMesh* const mesh); +NEWTON_API dFloat64* NewtonMeshGetVertexArray (const NewtonMesh* const mesh); + + +NEWTON_API void* NewtonMeshGetFirstVertex (const NewtonMesh* const mesh); +NEWTON_API void* NewtonMeshGetNextVertex (const NewtonMesh* const mesh, const void* const vertex); +NEWTON_API int NewtonMeshGetVertexIndex (const NewtonMesh* const mesh, const void* const vertex); + +NEWTON_API void* NewtonMeshGetFirstPoint (const NewtonMesh* const mesh); +NEWTON_API void* NewtonMeshGetNextPoint (const NewtonMesh* const mesh, const void* const point); +NEWTON_API int NewtonMeshGetPointIndex (const NewtonMesh* const mesh, const void* const point); +NEWTON_API int NewtonMeshGetVertexIndexFromPoint (const NewtonMesh* const mesh, const void* const point); + + +NEWTON_API void* NewtonMeshGetFirstEdge (const NewtonMesh* const mesh); +NEWTON_API void* NewtonMeshGetNextEdge (const NewtonMesh* const mesh, const void* const edge); +NEWTON_API void NewtonMeshGetEdgeIndices (const NewtonMesh* const mesh, const void* const edge, int* const v0, int* const v1); +//NEWTON_API void NewtonMeshGetEdgePointIndices (const NewtonMesh* const mesh, const void* const edge, int* const v0, int* const v1); + +NEWTON_API void* NewtonMeshGetFirstFace (const NewtonMesh* const mesh); +NEWTON_API void* NewtonMeshGetNextFace (const NewtonMesh* const mesh, const void* const face); +NEWTON_API int NewtonMeshIsFaceOpen (const NewtonMesh* const mesh, const void* const face); +NEWTON_API int NewtonMeshGetFaceMaterial (const NewtonMesh* const mesh, const void* const face); +NEWTON_API int NewtonMeshGetFaceIndexCount (const NewtonMesh* const mesh, const void* const face); +NEWTON_API void NewtonMeshGetFaceIndices (const NewtonMesh* const mesh, const void* const face, int* const indices); +NEWTON_API void NewtonMeshGetFacePointIndices (const NewtonMesh* const mesh, const void* const face, int* const indices); + + +#ifdef __cplusplus +} +#endif + +#endif + + + diff --git a/src/Nazara/Physics/Physics.cpp b/src/Nazara/Physics/Physics.cpp new file mode 100644 index 000000000..961aed0d5 --- /dev/null +++ b/src/Nazara/Physics/Physics.cpp @@ -0,0 +1,57 @@ +// Copyright (C) 2012 Jérôme Leclercq / Rémi Bèges +// This file is part of the "Nazara Engine". +// For conditions of distribution and use, see copyright notice in Config.hpp + +#include +#include +#include +#include + +NzPhysics::NzPhysics() +{ +} + +NzPhysics::~NzPhysics() +{ + if (s_initialized) + Uninitialize(); +} + +bool NzPhysics::Initialize() +{ + #if NAZARA_PHYSICS_SAFE + if (s_initialized) + { + NazaraError("Physics already initialized"); + return true; + } + #endif + + // Initialisation du module + + s_initialized = true; + + return true; +} + +void NzPhysics::Uninitialize() +{ + #if NAZARA_PHYSICS_SAFE + if (!s_initialized) + { + NazaraError("Physics not initialized"); + return; + } + #endif + + // Libération du module + + s_initialized = false; +} + +bool NzPhysics::IsInitialized() +{ + return s_initialized; +} + +bool NzPhysics::s_initialized = false; diff --git a/src/Nazara/Physics/PhysicsSolver.cpp b/src/Nazara/Physics/PhysicsSolver.cpp new file mode 100644 index 000000000..9799a29f4 --- /dev/null +++ b/src/Nazara/Physics/PhysicsSolver.cpp @@ -0,0 +1,46 @@ +// Copyright (C) 2012 Jérôme Leclercq / Rémi Bèges +// This file is part of the "Nazara Engine". +// For conditions of distribution and use, see copyright notice in Config.hpp + +#include "PhysicsWorld.hpp" +//#include +#include "PhysicsSolver.hpp" +//#include +#include + +#include + +NzPhysicsSolver::NzPhysicsSolver(nzSolverMode mode, unsigned int numberOfPassesLinearMode) +{ + m_mode = mode; + m_numberOfPassesLinearMode = numberOfPassesLinearMode; +} + +void NzPhysicsSolver::Configure(nzSolverMode mode, unsigned int numberOfPassesLinearMode) +{ + m_mode = mode; + m_numberOfPassesLinearMode = numberOfPassesLinearMode; +} + +void NzPhysicsSolver::Set(NzPhysicsWorld* world) +{ + switch(m_mode) + { + case nzExact: + NewtonSetSolverModel(world, 0); + break; + + case nzAdaptative: + NewtonSetSolverModel(world, 1); + break; + + case nzLinear: + NewtonSetSolverModel(world, m_numberOfPassesLinearMode); + + } +} + +NzPhysicsSolver::~NzPhysicsSolver() +{ + //dtor +} diff --git a/src/Nazara/Physics/PhysicsWorld.cpp b/src/Nazara/Physics/PhysicsWorld.cpp new file mode 100644 index 000000000..e174b5ecb --- /dev/null +++ b/src/Nazara/Physics/PhysicsWorld.cpp @@ -0,0 +1,60 @@ +// Copyright (C) 2012 Jérôme Leclercq / Rémi Bèges +// This file is part of the "Nazara Engine". +// For conditions of distribution and use, see copyright notice in Config.hpp + +#include "PhysicsWorld.hpp" +//#include +#include "PhysicsSolver.hpp" +//#include + +#include + +NzPhysicsWorld::NzPhysicsWorld() +{ + m_world = NewtonCreate(); + m_solver.Configure(nzLinear,10); + m_solver.Set(this); + SetFrictionModel(nzAdaptative); +} + +NzPhysicsWorld::~NzPhysicsWorld() +{ + NewtonDestroy(m_world); +} + +void NzPhysicsWorld::SetPhysicsSolverSolver(const NzPhysicsSolver& solver) +{ + m_solver = solver; + m_solver.Set(this); +} + +const nzSolverMode& NzPhysicsWorld::GetPhysicsSolver() +{ + return m_solver; +} + +void NzPhysicsWorld::SetFrictionModel(nzFrictionModel model) +{ + switch(model) + { + case nzExact: + NewtonSetFrictionModel(this,0); + break; + + case nzAdaptative: + NewtonSetFrictionModel(this,1); + break; + } + + m_frictionModel = model; +} + +const nzFrictionModel& NzPhysicsWorld::GetFrictionModel() +{ + return m_frictionModel; +} + +void NzPhysicsWorld::UpdatePhysics(nzUint64 timestep) +{ + NewtonUpdate(m_world,static_cast(timestep));//FLOAT WTF ? +} From f1865e5030e756561f3d52ea7c83998544862457 Mon Sep 17 00:00:00 2001 From: Remi Beges Date: Mon, 18 Jun 2012 10:24:06 +0200 Subject: [PATCH 04/14] Sligthly changed interface & added functionnalities NzPhysicsWorld has now a public pointer to NewtonWorld NzCollisionShape added, can be constructed from a NzCube for now NzPhysicsEntity added Minor fix + typo --- include/Nazara/Physics/CollisionShape.hpp | 36 +++++++++++++++++++ include/Nazara/Physics/Debug.hpp | 2 +- include/Nazara/Physics/PhysicsEntity.hpp | 33 +++++++++++++++++ include/Nazara/Physics/PhysicsWorld.hpp | 29 +++++++++------ include/Nazara/Physics/StaticBody.hpp | 23 ++++++++++++ src/Nazara/Physics/CollisionShape.cpp | 33 +++++++++++++++++ src/Nazara/Physics/PhysicsEntity.cpp | 44 +++++++++++++++++++++++ src/Nazara/Physics/PhysicsSolver.cpp | 6 ++-- src/Nazara/Physics/PhysicsWorld.cpp | 41 +++++++++++++++------ src/Nazara/Physics/StaticBody.cpp | 18 ++++++++++ 10 files changed, 240 insertions(+), 25 deletions(-) create mode 100644 include/Nazara/Physics/CollisionShape.hpp create mode 100644 include/Nazara/Physics/PhysicsEntity.hpp create mode 100644 include/Nazara/Physics/StaticBody.hpp create mode 100644 src/Nazara/Physics/CollisionShape.cpp create mode 100644 src/Nazara/Physics/PhysicsEntity.cpp create mode 100644 src/Nazara/Physics/StaticBody.cpp diff --git a/include/Nazara/Physics/CollisionShape.hpp b/include/Nazara/Physics/CollisionShape.hpp new file mode 100644 index 000000000..4770decd8 --- /dev/null +++ b/include/Nazara/Physics/CollisionShape.hpp @@ -0,0 +1,36 @@ +// Copyright (C) 2012 Jérôme Leclercq / Rémi Bèges +// This file is part of the "Nazara Engine". +// For conditions of distribution and use, see copyright notice in Config.hpp + +#pragma once + +#ifndef COLLISIONSHAPE_HPP +#define COLLISIONSHAPE_HPP + +#include +#include "PhysicsWorld.hpp" +//#include + +class NzCollisionShape +{ + public: + NzCollisionShape(NzPhysicsWorld* world); + ~NzCollisionShape(); + + void Create(const NzVector3f& cubeSize); + //void Create(const NzSpheref& sphere); + //void Create(const NzConef& cone); + //void Create(const NzMesh& customMesh); + void Release(); + + bool IsValid(); + + NewtonCollision* newtonCollisionShape; + + protected: + private: + NzPhysicsWorld* m_world; + bool m_isCreated; +}; + +#endif // COLLISIONSHAPE_HPP diff --git a/include/Nazara/Physics/Debug.hpp b/include/Nazara/Physics/Debug.hpp index 933d5db67..a0144954a 100644 --- a/include/Nazara/Physics/Debug.hpp +++ b/include/Nazara/Physics/Debug.hpp @@ -2,7 +2,7 @@ // This file is part of the "Nazara Engine". // For conditions of distribution and use, see copyright notice in Config.hpp -#include +#include #if NAZARA_PHYSICS_MEMORYLEAKTRACKER || defined(NAZARA_DEBUG) #include diff --git a/include/Nazara/Physics/PhysicsEntity.hpp b/include/Nazara/Physics/PhysicsEntity.hpp new file mode 100644 index 000000000..3f9e9a40b --- /dev/null +++ b/include/Nazara/Physics/PhysicsEntity.hpp @@ -0,0 +1,33 @@ +// Copyright (C) 2012 Jérôme Leclercq / Rémi Bèges +// This file is part of the "Nazara Engine". +// For conditions of distribution and use, see copyright notice in Config.hpp + +#pragma once + +#ifndef PHYSICSENTITY_HPP +#define PHYSICSENTITY_HPP + +#include +#include +#include +//#include +#include "CollisionShape.hpp" + +class NzPhysicsWorld; + +class NzPhysicsEntity +{ + public: + NzPhysicsEntity(NzPhysicsWorld* world, const NzCollisionShape& shape, const NzVector3f& position, float mass); + virtual void Init(); + virtual ~NzPhysicsEntity(); + protected: + NzPhysicsWorld* m_world; + NewtonBody* m_body; + float m_mass; + NzMatrix4f m_entityMatrix; + private: + +}; + +#endif // PHYSICSENTITY_HPP diff --git a/include/Nazara/Physics/PhysicsWorld.hpp b/include/Nazara/Physics/PhysicsWorld.hpp index b0eda5f26..e52536ce5 100644 --- a/include/Nazara/Physics/PhysicsWorld.hpp +++ b/include/Nazara/Physics/PhysicsWorld.hpp @@ -9,34 +9,43 @@ #include #include +#include +#include +#include "PhysicsSolver.hpp" +//#include -enum nzFrictionModel -{ - nzExact, - nzAdaptative -}; - -class NzPhysicsSolver; +//TODO : ajouter Axis Aligned Bounding Box class NzPhysicsWorld { + enum nzFrictionModel + { + nzExact, + nzAdaptative + }; + public: NzPhysicsWorld(); ~NzPhysicsWorld(); + void SetSize(const NzCubef& size); + const NzCubef& GetSize() const; + void SetPhysicsSolver(const NzPhysicsSolver& solver); const NzPhysicsSolver& GetPhysicsSolver() const; void SetFrictionModel(nzFrictionModel model); - const nzFrictionModel& GetFrictionModel(); + const nzFrictionModel& GetFrictionModel() const; - void UpdatePhysics(nzUint64 timestep); + void UpdatePhysics(float timestep); + + NewtonWorld* newtonWorld; protected: private: - NewtonWorld* m_world; NzPhysicsSolver m_solver; nzFrictionModel m_frictionModel; + NzCubef m_size; }; #endif // PHYSICSWORLD_HPP diff --git a/include/Nazara/Physics/StaticBody.hpp b/include/Nazara/Physics/StaticBody.hpp new file mode 100644 index 000000000..222c15b05 --- /dev/null +++ b/include/Nazara/Physics/StaticBody.hpp @@ -0,0 +1,23 @@ +// Copyright (C) 2012 Jérôme Leclercq / Rémi Bèges +// This file is part of the "Nazara Engine". +// For conditions of distribution and use, see copyright notice in Config.hpp + +#pragma once + +#ifndef STATICBODY_HPP +#define STATICBODY_HPP + +#include +//#include +#include "PhysicsEntity.hpp" + +class NzStaticBody : public NzPhysicsEntity +{ + public: + NzStaticBody(NzPhysicsWorld* world, const NzCollisionShape& shape, const NzVector3f& position, float mass); + ~NzStaticBody(); + protected: + private: +}; + +#endif // STATICBODY_HPP diff --git a/src/Nazara/Physics/CollisionShape.cpp b/src/Nazara/Physics/CollisionShape.cpp new file mode 100644 index 000000000..839c312a1 --- /dev/null +++ b/src/Nazara/Physics/CollisionShape.cpp @@ -0,0 +1,33 @@ +// Copyright (C) 2012 Jérôme Leclercq / Rémi Bèges +// This file is part of the "Nazara Engine". +// For conditions of distribution and use, see copyright notice in Config.hpp + +#include "CollisionShape.hpp" +//#include +#include + +NzCollisionShape::NzCollisionShape(NzPhysicsWorld* world) +{ + m_world = world; + m_isCreated = false; + newtonCollisionShape = nullptr; +} + +NzCollisionShape::~NzCollisionShape() +{ + if(m_isCreated) + NewtonReleaseCollision(m_world->newtonWorld, newtonCollisionShape); +} + +void NzCollisionShape::Create(const NzVector3f& cubeSize) +{ + newtonCollisionShape = NewtonCreateBox(m_world->newtonWorld, static_cast(cubeSize.x), + static_cast(cubeSize.y), + static_cast(cubeSize.z), 0, NULL); +} + +void NzCollisionShape::Release() +{ + if(m_isCreated) + NewtonReleaseCollision(m_world->newtonWorld, newtonCollisionShape); +} diff --git a/src/Nazara/Physics/PhysicsEntity.cpp b/src/Nazara/Physics/PhysicsEntity.cpp new file mode 100644 index 000000000..51d3e965a --- /dev/null +++ b/src/Nazara/Physics/PhysicsEntity.cpp @@ -0,0 +1,44 @@ +// Copyright (C) 2012 Jérôme Leclercq / Rémi Bèges +// This file is part of the "Nazara Engine". +// For conditions of distribution and use, see copyright notice in Config.hpp + +#include "PhysicsWorld.hpp" +//#include +#include "PhysicsEntity.hpp" +//#include +#include + +NzPhysicsEntity::NzPhysicsEntity(NzPhysicsWorld* world, const NzCollisionShape& shape, const NzVector3f& position, float mass) : m_world(world), m_mass(mass) +{ + m_entityMatrix.SetIdentity(); + m_entityMatrix.SetTranslation(position); + + m_body = NewtonCreateBody(world->newtonWorld, shape.newtonCollisionShape,NULL); + + //NewtonBodySetMatrix(m_pBody, /*&m_entityMatrix.matrice [0][0]*/);//Passage dgMatrix a NzMatrix4 ?? + +//Pour rigid bodies uniquement + /* + // On calcul l'inertie du corps, en passant par une petite formule + CVector inertie; + + inertie.x = 0.7f * m_masse * (m_taille.y * m_taille.y + m_taille.z * m_taille.z) / 12; + inertie.y = 0.7f * m_masse * (m_taille.x * m_taille.x + m_taille.z * m_taille.z) / 12; + inertie.z = 0.7f * m_masse * (m_taille.x * m_taille.x + m_taille.y * m_taille.y) / 12; + + // On définit ensuite la masse et l'inertie pour ce corps + NewtonBodySetMassMatrix (m_pBody, m_masse, inertie.x, inertie.y, inertie.z); + + // On règle enfin le Callback, qui sera nécessaire pour que le corps bouge + NewtonBodySetForceAndTorqueCallback (m_pBody, ApplyForceAndTorqueCallback);*/ +} + +void NzPhysicsEntity::Init() +{ + +} + +NzPhysicsEntity::~NzPhysicsEntity() +{ + NewtonDestroyBody(m_world->newtonWorld,m_body); +} diff --git a/src/Nazara/Physics/PhysicsSolver.cpp b/src/Nazara/Physics/PhysicsSolver.cpp index 9799a29f4..e062dc4ed 100644 --- a/src/Nazara/Physics/PhysicsSolver.cpp +++ b/src/Nazara/Physics/PhysicsSolver.cpp @@ -27,15 +27,15 @@ void NzPhysicsSolver::Set(NzPhysicsWorld* world) switch(m_mode) { case nzExact: - NewtonSetSolverModel(world, 0); + NewtonSetSolverModel(world->newtonWorld, 0); break; case nzAdaptative: - NewtonSetSolverModel(world, 1); + NewtonSetSolverModel(world->newtonWorld, 1); break; case nzLinear: - NewtonSetSolverModel(world, m_numberOfPassesLinearMode); + NewtonSetSolverModel(world->newtonWorld, m_numberOfPassesLinearMode); } } diff --git a/src/Nazara/Physics/PhysicsWorld.cpp b/src/Nazara/Physics/PhysicsWorld.cpp index e174b5ecb..dabbfd91b 100644 --- a/src/Nazara/Physics/PhysicsWorld.cpp +++ b/src/Nazara/Physics/PhysicsWorld.cpp @@ -4,14 +4,12 @@ #include "PhysicsWorld.hpp" //#include -#include "PhysicsSolver.hpp" -//#include #include NzPhysicsWorld::NzPhysicsWorld() { - m_world = NewtonCreate(); + newtonWorld = NewtonCreate(); m_solver.Configure(nzLinear,10); m_solver.Set(this); SetFrictionModel(nzAdaptative); @@ -19,16 +17,37 @@ NzPhysicsWorld::NzPhysicsWorld() NzPhysicsWorld::~NzPhysicsWorld() { - NewtonDestroy(m_world); + NewtonDestroy(newtonWorld); } -void NzPhysicsWorld::SetPhysicsSolverSolver(const NzPhysicsSolver& solver) +void NzPhysicsWorld::SetSize(const NzCubef& size) +{ + m_size = size; + float bottom[3]; + bottom[0] = m_size.x; + bottom[1] = m_size.y; + bottom[2] = m_size.z; + float top[3]; + top[0] = m_size.x + m_size.width; + top[1] = m_size.y + m_size.height; + top[2] = m_size.z + m_size.depth; + + NewtonSetWorldSize(newtonWorld, static_cast(bottom), + static_cast(top)); +} + +const NzCubef& NzPhysicsWorld::GetSize() const +{ + return m_size; +} + +void NzPhysicsWorld::SetPhysicsSolver(const NzPhysicsSolver& solver) { m_solver = solver; m_solver.Set(this); } -const nzSolverMode& NzPhysicsWorld::GetPhysicsSolver() +const NzPhysicsSolver& NzPhysicsWorld::GetPhysicsSolver() const { return m_solver; } @@ -38,23 +57,23 @@ void NzPhysicsWorld::SetFrictionModel(nzFrictionModel model) switch(model) { case nzExact: - NewtonSetFrictionModel(this,0); + NewtonSetFrictionModel(newtonWorld,0); break; case nzAdaptative: - NewtonSetFrictionModel(this,1); + NewtonSetFrictionModel(newtonWorld,1); break; } m_frictionModel = model; } -const nzFrictionModel& NzPhysicsWorld::GetFrictionModel() +const NzPhysicsWorld::nzFrictionModel& NzPhysicsWorld::GetFrictionModel() const { return m_frictionModel; } -void NzPhysicsWorld::UpdatePhysics(nzUint64 timestep) +void NzPhysicsWorld::UpdatePhysics(float timestep) { - NewtonUpdate(m_world,static_cast(timestep));//FLOAT WTF ? + NewtonUpdate(newtonWorld,timestep);//FLOAT WTF ? } diff --git a/src/Nazara/Physics/StaticBody.cpp b/src/Nazara/Physics/StaticBody.cpp new file mode 100644 index 000000000..118d4b627 --- /dev/null +++ b/src/Nazara/Physics/StaticBody.cpp @@ -0,0 +1,18 @@ +// Copyright (C) 2012 Jérôme Leclercq / Rémi Bèges +// This file is part of the "Nazara Engine". +// For conditions of distribution and use, see copyright notice in Config.hpp + +#include "StaticBody.hpp" +//#include + +#include + +NzStaticBody::NzStaticBody(NzPhysicsWorld* world, const NzCollisionShape& shape, const NzVector3f& position, float mass) : NzPhysicsEntity(world,shape,position,mass) +{ + //ctor +} + +NzStaticBody::~NzStaticBody() +{ + //dtor +} From 9996a7169a133955b7eba25dd2d3959dc9696c9e Mon Sep 17 00:00:00 2001 From: Remi Beges Date: Tue, 19 Jun 2012 18:31:42 +0200 Subject: [PATCH 05/14] Removed Physics module --- include/Nazara/Physics/CollisionShape.hpp | 36 ----------- include/Nazara/Physics/Config.hpp | 38 ----------- include/Nazara/Physics/Debug.hpp | 11 ---- include/Nazara/Physics/DebugOff.hpp | 8 --- include/Nazara/Physics/Physics.hpp | 27 -------- include/Nazara/Physics/PhysicsEntity.hpp | 33 ---------- include/Nazara/Physics/PhysicsSolver.hpp | 34 ---------- include/Nazara/Physics/PhysicsWorld.hpp | 51 --------------- include/Nazara/Physics/StaticBody.hpp | 23 ------- src/Nazara/Physics/CollisionShape.cpp | 33 ---------- src/Nazara/Physics/Physics.cpp | 57 ---------------- src/Nazara/Physics/PhysicsEntity.cpp | 44 ------------- src/Nazara/Physics/PhysicsSolver.cpp | 46 ------------- src/Nazara/Physics/PhysicsWorld.cpp | 79 ----------------------- src/Nazara/Physics/StaticBody.cpp | 18 ------ 15 files changed, 538 deletions(-) delete mode 100644 include/Nazara/Physics/CollisionShape.hpp delete mode 100644 include/Nazara/Physics/Config.hpp delete mode 100644 include/Nazara/Physics/Debug.hpp delete mode 100644 include/Nazara/Physics/DebugOff.hpp delete mode 100644 include/Nazara/Physics/Physics.hpp delete mode 100644 include/Nazara/Physics/PhysicsEntity.hpp delete mode 100644 include/Nazara/Physics/PhysicsSolver.hpp delete mode 100644 include/Nazara/Physics/PhysicsWorld.hpp delete mode 100644 include/Nazara/Physics/StaticBody.hpp delete mode 100644 src/Nazara/Physics/CollisionShape.cpp delete mode 100644 src/Nazara/Physics/Physics.cpp delete mode 100644 src/Nazara/Physics/PhysicsEntity.cpp delete mode 100644 src/Nazara/Physics/PhysicsSolver.cpp delete mode 100644 src/Nazara/Physics/PhysicsWorld.cpp delete mode 100644 src/Nazara/Physics/StaticBody.cpp diff --git a/include/Nazara/Physics/CollisionShape.hpp b/include/Nazara/Physics/CollisionShape.hpp deleted file mode 100644 index 4770decd8..000000000 --- a/include/Nazara/Physics/CollisionShape.hpp +++ /dev/null @@ -1,36 +0,0 @@ -// Copyright (C) 2012 Jérôme Leclercq / Rémi Bèges -// This file is part of the "Nazara Engine". -// For conditions of distribution and use, see copyright notice in Config.hpp - -#pragma once - -#ifndef COLLISIONSHAPE_HPP -#define COLLISIONSHAPE_HPP - -#include -#include "PhysicsWorld.hpp" -//#include - -class NzCollisionShape -{ - public: - NzCollisionShape(NzPhysicsWorld* world); - ~NzCollisionShape(); - - void Create(const NzVector3f& cubeSize); - //void Create(const NzSpheref& sphere); - //void Create(const NzConef& cone); - //void Create(const NzMesh& customMesh); - void Release(); - - bool IsValid(); - - NewtonCollision* newtonCollisionShape; - - protected: - private: - NzPhysicsWorld* m_world; - bool m_isCreated; -}; - -#endif // COLLISIONSHAPE_HPP diff --git a/include/Nazara/Physics/Config.hpp b/include/Nazara/Physics/Config.hpp deleted file mode 100644 index a5af060c0..000000000 --- a/include/Nazara/Physics/Config.hpp +++ /dev/null @@ -1,38 +0,0 @@ -/* - Nazara Engine - - Copyright (C) 2012 AUTHORS (EMAIL) - - Permission is hereby granted, free of charge, to any person obtaining a copy of - this software and associated documentation files (the "Software"), to deal in - the Software without restriction, including without limitation the rights to - use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies - of the Software, and to permit persons to whom the Software is furnished to do - so, subject to the following conditions: - - The above copyright notice and this permission notice shall be included in all - copies or substantial portions of the Software. - - THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE - SOFTWARE. -*/ - -#pragma once - -#ifndef NAZARA_CONFIG_PHYSICS_HPP -#define NAZARA_CONFIG_PHYSICS_HPP - -/// Chaque modification d'un paramètre du module nécessite une recompilation de celui-ci - -// Utilise un tracker pour repérer les éventuels leaks (Ralentit l'exécution) -#define NAZARA_PHYSICS_MEMORYLEAKTRACKER 0 - -// Active les tests de sécurité basés sur le code (Conseillé pour le développement) -#define NAZARA_PHYSICS_SAFE 1 - -#endif // NAZARA_CONFIG_PHYSICS_HPP diff --git a/include/Nazara/Physics/Debug.hpp b/include/Nazara/Physics/Debug.hpp deleted file mode 100644 index a0144954a..000000000 --- a/include/Nazara/Physics/Debug.hpp +++ /dev/null @@ -1,11 +0,0 @@ -// Copyright (C) 2012 AUTHORS -// This file is part of the "Nazara Engine". -// For conditions of distribution and use, see copyright notice in Config.hpp - -#include -#if NAZARA_PHYSICS_MEMORYLEAKTRACKER || defined(NAZARA_DEBUG) - #include - - #define delete NzMemoryManager::NextFree(__FILE__, __LINE__), delete - #define new new(__FILE__, __LINE__) -#endif diff --git a/include/Nazara/Physics/DebugOff.hpp b/include/Nazara/Physics/DebugOff.hpp deleted file mode 100644 index 813b9165e..000000000 --- a/include/Nazara/Physics/DebugOff.hpp +++ /dev/null @@ -1,8 +0,0 @@ -// Copyright (C) 2012 AUTHORS -// This file is part of the "Nazara Engine". -// For conditions of distribution and use, see copyright notice in Config.hpp - -#if NAZARA_PHYSICS_MEMORYLEAKTRACKER || defined(NAZARA_DEBUG) - #undef delete - #undef new -#endif diff --git a/include/Nazara/Physics/Physics.hpp b/include/Nazara/Physics/Physics.hpp deleted file mode 100644 index c36ce3fad..000000000 --- a/include/Nazara/Physics/Physics.hpp +++ /dev/null @@ -1,27 +0,0 @@ -// Copyright (C) 2012 Jérôme Leclercq / Rémi Bèges -// This file is part of the "Nazara Engine". -// For conditions of distribution and use, see copyright notice in Config.hpp - -#pragma once - -#ifndef NAZARA_PHYSICS_HPP -#define NAZARA_PHYSICS_HPP - -#include - -class NAZARA_API NzPhysics -{ - public: - NzPhysics(); - ~NzPhysics(); - - bool Initialize(); - void Uninitialize(); - - static bool IsInitialized(); - - private: - static bool s_initialized; -}; - -#endif // NAZARA_PHYSICS_HPP diff --git a/include/Nazara/Physics/PhysicsEntity.hpp b/include/Nazara/Physics/PhysicsEntity.hpp deleted file mode 100644 index 3f9e9a40b..000000000 --- a/include/Nazara/Physics/PhysicsEntity.hpp +++ /dev/null @@ -1,33 +0,0 @@ -// Copyright (C) 2012 Jérôme Leclercq / Rémi Bèges -// This file is part of the "Nazara Engine". -// For conditions of distribution and use, see copyright notice in Config.hpp - -#pragma once - -#ifndef PHYSICSENTITY_HPP -#define PHYSICSENTITY_HPP - -#include -#include -#include -//#include -#include "CollisionShape.hpp" - -class NzPhysicsWorld; - -class NzPhysicsEntity -{ - public: - NzPhysicsEntity(NzPhysicsWorld* world, const NzCollisionShape& shape, const NzVector3f& position, float mass); - virtual void Init(); - virtual ~NzPhysicsEntity(); - protected: - NzPhysicsWorld* m_world; - NewtonBody* m_body; - float m_mass; - NzMatrix4f m_entityMatrix; - private: - -}; - -#endif // PHYSICSENTITY_HPP diff --git a/include/Nazara/Physics/PhysicsSolver.hpp b/include/Nazara/Physics/PhysicsSolver.hpp deleted file mode 100644 index 86a7b0b17..000000000 --- a/include/Nazara/Physics/PhysicsSolver.hpp +++ /dev/null @@ -1,34 +0,0 @@ -// Copyright (C) 2012 Jérôme Leclercq / Rémi Bèges -// This file is part of the "Nazara Engine". -// For conditions of distribution and use, see copyright notice in Config.hpp - -#pragma once - -#ifndef PHYSICSSOLVER_HPP -#define PHYSICSSOLVER_HPP - -#include - -enum nzSolverMode -{ - nzExact, - nzAdaptative, - nzLinear -}; - -class NzPhysicsWorld; - -class NzPhysicsSolver -{ - public: - NzPhysicsSolver(nzSolverMode mode = nzLinear, unsigned int numberOfPassesLinearMode = 10); - void Configure(nzSolverMode mode, unsigned int numberOfPassesLinearMode); - void Set(NzPhysicsWorld* world); - ~NzPhysicsSolver(); - protected: - private: - nzSolverMode m_mode; - unsigned int m_numberOfPassesLinearMode; -}; - -#endif // PHYSICSSOLVER_HPP diff --git a/include/Nazara/Physics/PhysicsWorld.hpp b/include/Nazara/Physics/PhysicsWorld.hpp deleted file mode 100644 index e52536ce5..000000000 --- a/include/Nazara/Physics/PhysicsWorld.hpp +++ /dev/null @@ -1,51 +0,0 @@ -// Copyright (C) 2012 Jérôme Leclercq / Rémi Bèges -// This file is part of the "Nazara Engine". -// For conditions of distribution and use, see copyright notice in Config.hpp - -#pragma once - -#ifndef PHYSICSWORLD_HPP -#define PHYSICSWORLD_HPP - -#include -#include -#include -#include -#include "PhysicsSolver.hpp" -//#include - -//TODO : ajouter Axis Aligned Bounding Box - -class NzPhysicsWorld -{ - enum nzFrictionModel - { - nzExact, - nzAdaptative - }; - - public: - NzPhysicsWorld(); - ~NzPhysicsWorld(); - - void SetSize(const NzCubef& size); - const NzCubef& GetSize() const; - - void SetPhysicsSolver(const NzPhysicsSolver& solver); - const NzPhysicsSolver& GetPhysicsSolver() const; - - void SetFrictionModel(nzFrictionModel model); - const nzFrictionModel& GetFrictionModel() const; - - void UpdatePhysics(float timestep); - - NewtonWorld* newtonWorld; - - protected: - private: - NzPhysicsSolver m_solver; - nzFrictionModel m_frictionModel; - NzCubef m_size; -}; - -#endif // PHYSICSWORLD_HPP diff --git a/include/Nazara/Physics/StaticBody.hpp b/include/Nazara/Physics/StaticBody.hpp deleted file mode 100644 index 222c15b05..000000000 --- a/include/Nazara/Physics/StaticBody.hpp +++ /dev/null @@ -1,23 +0,0 @@ -// Copyright (C) 2012 Jérôme Leclercq / Rémi Bèges -// This file is part of the "Nazara Engine". -// For conditions of distribution and use, see copyright notice in Config.hpp - -#pragma once - -#ifndef STATICBODY_HPP -#define STATICBODY_HPP - -#include -//#include -#include "PhysicsEntity.hpp" - -class NzStaticBody : public NzPhysicsEntity -{ - public: - NzStaticBody(NzPhysicsWorld* world, const NzCollisionShape& shape, const NzVector3f& position, float mass); - ~NzStaticBody(); - protected: - private: -}; - -#endif // STATICBODY_HPP diff --git a/src/Nazara/Physics/CollisionShape.cpp b/src/Nazara/Physics/CollisionShape.cpp deleted file mode 100644 index 839c312a1..000000000 --- a/src/Nazara/Physics/CollisionShape.cpp +++ /dev/null @@ -1,33 +0,0 @@ -// Copyright (C) 2012 Jérôme Leclercq / Rémi Bèges -// This file is part of the "Nazara Engine". -// For conditions of distribution and use, see copyright notice in Config.hpp - -#include "CollisionShape.hpp" -//#include -#include - -NzCollisionShape::NzCollisionShape(NzPhysicsWorld* world) -{ - m_world = world; - m_isCreated = false; - newtonCollisionShape = nullptr; -} - -NzCollisionShape::~NzCollisionShape() -{ - if(m_isCreated) - NewtonReleaseCollision(m_world->newtonWorld, newtonCollisionShape); -} - -void NzCollisionShape::Create(const NzVector3f& cubeSize) -{ - newtonCollisionShape = NewtonCreateBox(m_world->newtonWorld, static_cast(cubeSize.x), - static_cast(cubeSize.y), - static_cast(cubeSize.z), 0, NULL); -} - -void NzCollisionShape::Release() -{ - if(m_isCreated) - NewtonReleaseCollision(m_world->newtonWorld, newtonCollisionShape); -} diff --git a/src/Nazara/Physics/Physics.cpp b/src/Nazara/Physics/Physics.cpp deleted file mode 100644 index 961aed0d5..000000000 --- a/src/Nazara/Physics/Physics.cpp +++ /dev/null @@ -1,57 +0,0 @@ -// Copyright (C) 2012 Jérôme Leclercq / Rémi Bèges -// This file is part of the "Nazara Engine". -// For conditions of distribution and use, see copyright notice in Config.hpp - -#include -#include -#include -#include - -NzPhysics::NzPhysics() -{ -} - -NzPhysics::~NzPhysics() -{ - if (s_initialized) - Uninitialize(); -} - -bool NzPhysics::Initialize() -{ - #if NAZARA_PHYSICS_SAFE - if (s_initialized) - { - NazaraError("Physics already initialized"); - return true; - } - #endif - - // Initialisation du module - - s_initialized = true; - - return true; -} - -void NzPhysics::Uninitialize() -{ - #if NAZARA_PHYSICS_SAFE - if (!s_initialized) - { - NazaraError("Physics not initialized"); - return; - } - #endif - - // Libération du module - - s_initialized = false; -} - -bool NzPhysics::IsInitialized() -{ - return s_initialized; -} - -bool NzPhysics::s_initialized = false; diff --git a/src/Nazara/Physics/PhysicsEntity.cpp b/src/Nazara/Physics/PhysicsEntity.cpp deleted file mode 100644 index 51d3e965a..000000000 --- a/src/Nazara/Physics/PhysicsEntity.cpp +++ /dev/null @@ -1,44 +0,0 @@ -// Copyright (C) 2012 Jérôme Leclercq / Rémi Bèges -// This file is part of the "Nazara Engine". -// For conditions of distribution and use, see copyright notice in Config.hpp - -#include "PhysicsWorld.hpp" -//#include -#include "PhysicsEntity.hpp" -//#include -#include - -NzPhysicsEntity::NzPhysicsEntity(NzPhysicsWorld* world, const NzCollisionShape& shape, const NzVector3f& position, float mass) : m_world(world), m_mass(mass) -{ - m_entityMatrix.SetIdentity(); - m_entityMatrix.SetTranslation(position); - - m_body = NewtonCreateBody(world->newtonWorld, shape.newtonCollisionShape,NULL); - - //NewtonBodySetMatrix(m_pBody, /*&m_entityMatrix.matrice [0][0]*/);//Passage dgMatrix a NzMatrix4 ?? - -//Pour rigid bodies uniquement - /* - // On calcul l'inertie du corps, en passant par une petite formule - CVector inertie; - - inertie.x = 0.7f * m_masse * (m_taille.y * m_taille.y + m_taille.z * m_taille.z) / 12; - inertie.y = 0.7f * m_masse * (m_taille.x * m_taille.x + m_taille.z * m_taille.z) / 12; - inertie.z = 0.7f * m_masse * (m_taille.x * m_taille.x + m_taille.y * m_taille.y) / 12; - - // On définit ensuite la masse et l'inertie pour ce corps - NewtonBodySetMassMatrix (m_pBody, m_masse, inertie.x, inertie.y, inertie.z); - - // On règle enfin le Callback, qui sera nécessaire pour que le corps bouge - NewtonBodySetForceAndTorqueCallback (m_pBody, ApplyForceAndTorqueCallback);*/ -} - -void NzPhysicsEntity::Init() -{ - -} - -NzPhysicsEntity::~NzPhysicsEntity() -{ - NewtonDestroyBody(m_world->newtonWorld,m_body); -} diff --git a/src/Nazara/Physics/PhysicsSolver.cpp b/src/Nazara/Physics/PhysicsSolver.cpp deleted file mode 100644 index e062dc4ed..000000000 --- a/src/Nazara/Physics/PhysicsSolver.cpp +++ /dev/null @@ -1,46 +0,0 @@ -// Copyright (C) 2012 Jérôme Leclercq / Rémi Bèges -// This file is part of the "Nazara Engine". -// For conditions of distribution and use, see copyright notice in Config.hpp - -#include "PhysicsWorld.hpp" -//#include -#include "PhysicsSolver.hpp" -//#include -#include - -#include - -NzPhysicsSolver::NzPhysicsSolver(nzSolverMode mode, unsigned int numberOfPassesLinearMode) -{ - m_mode = mode; - m_numberOfPassesLinearMode = numberOfPassesLinearMode; -} - -void NzPhysicsSolver::Configure(nzSolverMode mode, unsigned int numberOfPassesLinearMode) -{ - m_mode = mode; - m_numberOfPassesLinearMode = numberOfPassesLinearMode; -} - -void NzPhysicsSolver::Set(NzPhysicsWorld* world) -{ - switch(m_mode) - { - case nzExact: - NewtonSetSolverModel(world->newtonWorld, 0); - break; - - case nzAdaptative: - NewtonSetSolverModel(world->newtonWorld, 1); - break; - - case nzLinear: - NewtonSetSolverModel(world->newtonWorld, m_numberOfPassesLinearMode); - - } -} - -NzPhysicsSolver::~NzPhysicsSolver() -{ - //dtor -} diff --git a/src/Nazara/Physics/PhysicsWorld.cpp b/src/Nazara/Physics/PhysicsWorld.cpp deleted file mode 100644 index dabbfd91b..000000000 --- a/src/Nazara/Physics/PhysicsWorld.cpp +++ /dev/null @@ -1,79 +0,0 @@ -// Copyright (C) 2012 Jérôme Leclercq / Rémi Bèges -// This file is part of the "Nazara Engine". -// For conditions of distribution and use, see copyright notice in Config.hpp - -#include "PhysicsWorld.hpp" -//#include - -#include - -NzPhysicsWorld::NzPhysicsWorld() -{ - newtonWorld = NewtonCreate(); - m_solver.Configure(nzLinear,10); - m_solver.Set(this); - SetFrictionModel(nzAdaptative); -} - -NzPhysicsWorld::~NzPhysicsWorld() -{ - NewtonDestroy(newtonWorld); -} - -void NzPhysicsWorld::SetSize(const NzCubef& size) -{ - m_size = size; - float bottom[3]; - bottom[0] = m_size.x; - bottom[1] = m_size.y; - bottom[2] = m_size.z; - float top[3]; - top[0] = m_size.x + m_size.width; - top[1] = m_size.y + m_size.height; - top[2] = m_size.z + m_size.depth; - - NewtonSetWorldSize(newtonWorld, static_cast(bottom), - static_cast(top)); -} - -const NzCubef& NzPhysicsWorld::GetSize() const -{ - return m_size; -} - -void NzPhysicsWorld::SetPhysicsSolver(const NzPhysicsSolver& solver) -{ - m_solver = solver; - m_solver.Set(this); -} - -const NzPhysicsSolver& NzPhysicsWorld::GetPhysicsSolver() const -{ - return m_solver; -} - -void NzPhysicsWorld::SetFrictionModel(nzFrictionModel model) -{ - switch(model) - { - case nzExact: - NewtonSetFrictionModel(newtonWorld,0); - break; - - case nzAdaptative: - NewtonSetFrictionModel(newtonWorld,1); - break; - } - - m_frictionModel = model; -} - -const NzPhysicsWorld::nzFrictionModel& NzPhysicsWorld::GetFrictionModel() const -{ - return m_frictionModel; -} - -void NzPhysicsWorld::UpdatePhysics(float timestep) -{ - NewtonUpdate(newtonWorld,timestep);//FLOAT WTF ? -} diff --git a/src/Nazara/Physics/StaticBody.cpp b/src/Nazara/Physics/StaticBody.cpp deleted file mode 100644 index 118d4b627..000000000 --- a/src/Nazara/Physics/StaticBody.cpp +++ /dev/null @@ -1,18 +0,0 @@ -// Copyright (C) 2012 Jérôme Leclercq / Rémi Bèges -// This file is part of the "Nazara Engine". -// For conditions of distribution and use, see copyright notice in Config.hpp - -#include "StaticBody.hpp" -//#include - -#include - -NzStaticBody::NzStaticBody(NzPhysicsWorld* world, const NzCollisionShape& shape, const NzVector3f& position, float mass) : NzPhysicsEntity(world,shape,position,mass) -{ - //ctor -} - -NzStaticBody::~NzStaticBody() -{ - //dtor -} From 10a436b4814f94c93b69902bd2b1d812b67c5784 Mon Sep 17 00:00:00 2001 From: Remi Beges Date: Wed, 20 Jun 2012 20:36:14 +0200 Subject: [PATCH 06/14] Made operator< of strict order --- include/Nazara/Math/Vector2.inl | 2 +- include/Nazara/Math/Vector3.inl | 2 +- include/Nazara/Math/Vector4.inl | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/include/Nazara/Math/Vector2.inl b/include/Nazara/Math/Vector2.inl index 3889aaa78..5b9d58261 100644 --- a/include/Nazara/Math/Vector2.inl +++ b/include/Nazara/Math/Vector2.inl @@ -342,7 +342,7 @@ bool NzVector2::operator!=(const NzVector2& vec) const template bool NzVector2::operator<(const NzVector2& vec) const { - return x < vec.x && y < vec.y; + return (x != vec.x) ? x < vec.x : y < vec.y; } template diff --git a/include/Nazara/Math/Vector3.inl b/include/Nazara/Math/Vector3.inl index 73eff32fe..9a40aac0f 100644 --- a/include/Nazara/Math/Vector3.inl +++ b/include/Nazara/Math/Vector3.inl @@ -374,7 +374,7 @@ bool NzVector3::operator!=(const NzVector3& vec) const template bool NzVector3::operator<(const NzVector3& vec) const { - return x < vec.x && y < vec.y && z < vec.z; + return (x != vec.x) ? x < vec.x : (y != vec.y) ? y < vec.y : z < vec.z; } template diff --git a/include/Nazara/Math/Vector4.inl b/include/Nazara/Math/Vector4.inl index e5ec906fd..918e588a5 100644 --- a/include/Nazara/Math/Vector4.inl +++ b/include/Nazara/Math/Vector4.inl @@ -339,7 +339,7 @@ bool NzVector4::operator!=(const NzVector4& vec) const template bool NzVector4::operator<(const NzVector4& vec) const { - return x < vec.x && y < vec.y && z < vec.z && w < vec.w; + return (x != vec.x) ? x < vec.x : (y != vec.y) ? y < vec.y : (z != vec.z) ? z < vec.z : w < vec.w; } template From 354d7ed002a7b79b0efa45f93f95711687c37af8 Mon Sep 17 00:00:00 2001 From: Remi Beges Date: Tue, 24 Jul 2012 14:21:56 +0200 Subject: [PATCH 07/14] Improved interface *MappedNoiseBase provides a gain and offset control on the noise value *AbstractXDNoise provides a way to contain different noises in a std container and access the main "GetValue" member function *Applied minor optimisation to Perlin4D (previously forgotten) --- include/Nazara/Noise/Abstract2DNoise.hpp | 24 + include/Nazara/Noise/Abstract2DNoise.inl | 23 + include/Nazara/Noise/Abstract3DNoise.hpp | 23 + include/Nazara/Noise/Abstract3DNoise.inl | 23 + include/Nazara/Noise/Abstract4DNoise.hpp | 24 + include/Nazara/Noise/Abstract4DNoise.inl | 23 + include/Nazara/Noise/MappedNoiseBase.hpp | 32 + include/Nazara/Noise/MappedNoiseBase.inl | 62 ++ include/Nazara/Noise/Perlin2D.hpp | 5 +- include/Nazara/Noise/Perlin2D.inl | 6 +- include/Nazara/Noise/Perlin3D.hpp | 5 +- include/Nazara/Noise/Perlin3D.inl | 8 +- include/Nazara/Noise/Perlin4D.hpp | 6 +- include/Nazara/Noise/Perlin4D.inl | 64 +- include/Nazara/Noise/Simplex2D.hpp | 5 +- include/Nazara/Noise/Simplex2D.inl | 6 +- include/Nazara/Noise/Simplex3D.hpp | 5 +- include/Nazara/Noise/Simplex3D.inl | 8 +- include/Nazara/Noise/Simplex4D.hpp | 5 +- include/Nazara/Noise/Simplex4D.inl | 10 +- include/Newton/JointLibrary.h | 190 ---- include/Newton/Newton.h | 1059 ---------------------- 22 files changed, 303 insertions(+), 1313 deletions(-) create mode 100644 include/Nazara/Noise/Abstract2DNoise.hpp create mode 100644 include/Nazara/Noise/Abstract2DNoise.inl create mode 100644 include/Nazara/Noise/Abstract3DNoise.hpp create mode 100644 include/Nazara/Noise/Abstract3DNoise.inl create mode 100644 include/Nazara/Noise/Abstract4DNoise.hpp create mode 100644 include/Nazara/Noise/Abstract4DNoise.inl create mode 100644 include/Nazara/Noise/MappedNoiseBase.hpp create mode 100644 include/Nazara/Noise/MappedNoiseBase.inl delete mode 100644 include/Newton/JointLibrary.h delete mode 100644 include/Newton/Newton.h diff --git a/include/Nazara/Noise/Abstract2DNoise.hpp b/include/Nazara/Noise/Abstract2DNoise.hpp new file mode 100644 index 000000000..819c528d3 --- /dev/null +++ b/include/Nazara/Noise/Abstract2DNoise.hpp @@ -0,0 +1,24 @@ +// Copyright (C) 2012 Rémi Bèges +// This file is part of the "Nazara Engine". +// For conditions of distribution and use, see copyright notice in Config.hpp + +#pragma once + +#ifndef NAZARA_ABSTRACT2DNOISE_HPP +#define NAZARA_ABSTRACT2DNOISE_HPP + +#include +#include + +template class NAZARA_API NzAbstract2DNoise : public NzMappedNoiseBase +{ + public: + virtual T GetMappedValue(T x, T y); + virtual T GetValue(T x, T y, T resolution) = 0; + virtual T GetValue(T x, T y); + +}; + +#include + +#endif // NAZARA_ABSTRACT2DNOISE_HPP diff --git a/include/Nazara/Noise/Abstract2DNoise.inl b/include/Nazara/Noise/Abstract2DNoise.inl new file mode 100644 index 000000000..868e6fda1 --- /dev/null +++ b/include/Nazara/Noise/Abstract2DNoise.inl @@ -0,0 +1,23 @@ +// Copyright (C) 2012 Rémi Bèges +// This file is part of the "Nazara Engine". +// For conditions of distribution and use, see copyright notice in Config.hpp + +#include +#include +#include +#include +#include + +template +T NzAbstract2DNoise::GetMappedValue(T x, T y) +{ + return GetValue(x,y,this->m_resolution) * this->m_gain + this->m_offset; +} + +template +T NzAbstract2DNoise::GetValue(T x, T y) +{ + return GetValue(x,y,this->m_resolution); +} + +#include diff --git a/include/Nazara/Noise/Abstract3DNoise.hpp b/include/Nazara/Noise/Abstract3DNoise.hpp new file mode 100644 index 000000000..8ae002425 --- /dev/null +++ b/include/Nazara/Noise/Abstract3DNoise.hpp @@ -0,0 +1,23 @@ +// Copyright (C) 2012 Rémi Bèges +// This file is part of the "Nazara Engine". +// For conditions of distribution and use, see copyright notice in Config.hpp + +#pragma once + +#ifndef NAZARA_ABSTRACT3DNOISE_HPP +#define NAZARA_ABSTRACT3DNOISE_HPP + +#include +#include + +template class NAZARA_API NzAbstract3DNoise : public NzMappedNoiseBase +{ + public: + virtual T GetMappedValue(T x, T y, T z); + virtual T GetValue(T x, T y, T z) = 0; + virtual T GetValue(T x, T y, T z, T resolution); +}; + +#include + +#endif // NAZARA_ABSTRACT3DNOISE_HPP diff --git a/include/Nazara/Noise/Abstract3DNoise.inl b/include/Nazara/Noise/Abstract3DNoise.inl new file mode 100644 index 000000000..986fec840 --- /dev/null +++ b/include/Nazara/Noise/Abstract3DNoise.inl @@ -0,0 +1,23 @@ +// Copyright (C) 2012 Rémi Bèges +// This file is part of the "Nazara Engine". +// For conditions of distribution and use, see copyright notice in Config.hpp + +#include +#include +#include +#include +#include + +template +T NzAbstract3DNoise::GetMappedValue(T x, T y, T z) +{ + return GetValue(x,y,z) * m_gain + m_offset; +} + +template +T NzAbstract3DNoise::GetValue(T x, T y, T z, T resolution) +{ + return GetValue(x,y,z,this->m_resolution); +} + +#include diff --git a/include/Nazara/Noise/Abstract4DNoise.hpp b/include/Nazara/Noise/Abstract4DNoise.hpp new file mode 100644 index 000000000..f2d30f0ee --- /dev/null +++ b/include/Nazara/Noise/Abstract4DNoise.hpp @@ -0,0 +1,24 @@ +// Copyright (C) 2012 Rémi Bèges +// This file is part of the "Nazara Engine". +// For conditions of distribution and use, see copyright notice in Config.hpp + +#pragma once + +#ifndef NAZARA_ABSTRACT4DNOISE_HPP +#define NAZARA_ABSTRACT4DNOISE_HPP + +#include +#include + +template class NAZARA_API NzAbstract4DNoise : public NzMappedNoiseBase +{ + public: + virtual T GetMappedValue(T x, T y, T z, T w); + virtual T GetValue(T x, T y, T z, T w) = 0; + virtual T GetValue(T x, T y, T z, T w, T resolution); + +}; + +#include + +#endif // NAZARA_ABSTRACT4DNOISE_HPP diff --git a/include/Nazara/Noise/Abstract4DNoise.inl b/include/Nazara/Noise/Abstract4DNoise.inl new file mode 100644 index 000000000..09cbfd0df --- /dev/null +++ b/include/Nazara/Noise/Abstract4DNoise.inl @@ -0,0 +1,23 @@ +// Copyright (C) 2012 Rémi Bèges +// This file is part of the "Nazara Engine". +// For conditions of distribution and use, see copyright notice in Config.hpp + +#include +#include +#include +#include +#include + +template +T NzAbstract4DNoise::GetMappedValue(T x, T y, T z, T w) +{ + return GetValue(x,y,z,w) * m_gain + m_offset; +} + +template +T NzAbstract3DNoise::GetValue(T x, T y, T z, T resolution) +{ + return GetValue(x,y,z,w,this->m_resolution); +} + +#include diff --git a/include/Nazara/Noise/MappedNoiseBase.hpp b/include/Nazara/Noise/MappedNoiseBase.hpp new file mode 100644 index 000000000..d60046472 --- /dev/null +++ b/include/Nazara/Noise/MappedNoiseBase.hpp @@ -0,0 +1,32 @@ +// Copyright (C) 2012 Rémi Bèges +// This file is part of the "Nazara Engine". +// For conditions of distribution and use, see copyright notice in Config.hpp + +#pragma once + +#ifndef NAZARA_MAPPEDNOISEBASE_HPP +#define NAZARA_MAPPEDNOISEBASE_HPP + +#include + +template class NzMappedNoiseBase +{ + public: + NzMappedNoiseBase(); + ~NzMappedNoiseBase() = default; + + T GetGain() const; + T GetOffset() const; + T GetResolution() const; + void SetGain(T gain); + void SetOffset(T offset); + void SetResolution(T resolution); + protected: + T m_gain; + T m_offset; + T m_resolution; +}; + +#include + +#endif // NAZARA_MAPPEDNOISEBASE_HPP diff --git a/include/Nazara/Noise/MappedNoiseBase.inl b/include/Nazara/Noise/MappedNoiseBase.inl new file mode 100644 index 000000000..20cb90915 --- /dev/null +++ b/include/Nazara/Noise/MappedNoiseBase.inl @@ -0,0 +1,62 @@ +// Copyright (C) 2012 Rémi Bèges +// This file is part of the "Nazara Engine". +// For conditions of distribution and use, see copyright notice in Config.hpp + +#include +#include +#include +#include +#include +#include + + +template +NzMappedNoiseBase::NzMappedNoiseBase() : m_gain(1), m_offset(0), m_resolution(30) +{ + +} + +template +T NzMappedNoiseBase::GetGain() const +{ + return m_gain; +} + +template +T NzMappedNoiseBase::GetOffset() const +{ + return m_offset; +} + +template +T NzMappedNoiseBase::GetResolution() const +{ + return m_resolution; +} + +template +void NzMappedNoiseBase::SetGain(T gain) +{ + m_gain = gain; +} + +template +void NzMappedNoiseBase::SetOffset(T offset) +{ + m_offset = offset; +} + +template +void NzMappedNoiseBase::SetResolution(T resolution) +{ + if (NzNumberEquals(resolution, static_cast(0.0))) + { + NzStringStream ss; + ss << __FILE__ << ':' << __LINE__ << ": Division by zero"; + + throw std::domain_error(ss.ToString()); + } + m_resolution = static_cast(1.0)/resolution; +} + +#include diff --git a/include/Nazara/Noise/Perlin2D.hpp b/include/Nazara/Noise/Perlin2D.hpp index 18e7ae875..8109aaca3 100644 --- a/include/Nazara/Noise/Perlin2D.hpp +++ b/include/Nazara/Noise/Perlin2D.hpp @@ -9,13 +9,14 @@ #include #include +#include #include -template class NAZARA_API NzPerlin2D : public NzNoiseBase +template class NAZARA_API NzPerlin2D : public NzAbstract2DNoise, public NzNoiseBase { public: NzPerlin2D(); - T GetValue(T x, T y, T res); + T GetValue(T x, T y, T resolution); ~NzPerlin2D() = default; protected: private: diff --git a/include/Nazara/Noise/Perlin2D.inl b/include/Nazara/Noise/Perlin2D.inl index a823aba81..48b4e75b3 100644 --- a/include/Nazara/Noise/Perlin2D.inl +++ b/include/Nazara/Noise/Perlin2D.inl @@ -18,10 +18,10 @@ NzPerlin2D::NzPerlin2D() } template -T NzPerlin2D::GetValue(T x, T y, T res) +T NzPerlin2D::GetValue(T x, T y, T resolution) { - x /= res; - y /= res; + x *= resolution; + y *= resolution; x0 = fastfloor(x); y0 = fastfloor(y); diff --git a/include/Nazara/Noise/Perlin3D.hpp b/include/Nazara/Noise/Perlin3D.hpp index a425dc384..f93569005 100644 --- a/include/Nazara/Noise/Perlin3D.hpp +++ b/include/Nazara/Noise/Perlin3D.hpp @@ -9,13 +9,14 @@ #include #include +#include #include -template class NAZARA_API NzPerlin3D : public NzNoiseBase +template class NAZARA_API NzPerlin3D : public NzAbstract3DNoise, public NzNoiseBase { public: NzPerlin3D(); - T GetValue(T x, T y, T z, T res); + T GetValue(T x, T y, T z, T resolution); ~NzPerlin3D() = default; protected: private: diff --git a/include/Nazara/Noise/Perlin3D.inl b/include/Nazara/Noise/Perlin3D.inl index 60231979a..ec6afd286 100644 --- a/include/Nazara/Noise/Perlin3D.inl +++ b/include/Nazara/Noise/Perlin3D.inl @@ -22,11 +22,11 @@ NzPerlin3D::NzPerlin3D() } template -T NzPerlin3D::GetValue(T x, T y, T z, T res) +T NzPerlin3D::GetValue(T x, T y, T z, T resolution) { - x /= res; - y /= res; - z /= res; + x *= resolution; + y *= resolution; + z *= resolution; x0 = fastfloor(x); y0 = fastfloor(y); diff --git a/include/Nazara/Noise/Perlin4D.hpp b/include/Nazara/Noise/Perlin4D.hpp index b5a25ee4d..5b4ead5a8 100644 --- a/include/Nazara/Noise/Perlin4D.hpp +++ b/include/Nazara/Noise/Perlin4D.hpp @@ -9,13 +9,14 @@ #include #include +#include #include -template class NAZARA_API NzPerlin4D : public NzNoiseBase +template class NAZARA_API NzPerlin4D : public NzAbstract4DNoise, public NzNoiseBase { public: NzPerlin4D(); - T GetValue(T x, T y, T z, T w, T res); + T GetValue(T x, T y, T z, T w, T resolution); ~NzPerlin4D() = default; protected: private: @@ -26,7 +27,6 @@ template class NAZARA_API NzPerlin4D : public NzNoiseBase T Li1,Li2,Li3,Li4,Li5,Li6,Li7,Li8,Li9,Li10,Li11,Li12,Li13,Li14; T s[4],t[4],u[4],v[4]; T Cx,Cy,Cz,Cw; - T nx,ny,nz,nw; T tmp; NzVector4 temp; diff --git a/include/Nazara/Noise/Perlin4D.inl b/include/Nazara/Noise/Perlin4D.inl index b009098f8..d44076542 100644 --- a/include/Nazara/Noise/Perlin4D.inl +++ b/include/Nazara/Noise/Perlin4D.inl @@ -27,17 +27,17 @@ NzPerlin4D::NzPerlin4D() } template -T NzPerlin4D::GetValue(T x, T y, T z, T w, T res) +T NzPerlin4D::GetValue(T x, T y, T z, T w, T resolution) { - nx = x/res; - ny = y/res; - nz = z/res; - nw = w/res; + x *= resolution; + y *= resolution; + z *= resolution; + w *= resolution; - x0 = fastfloor(nx); - y0 = fastfloor(ny); - z0 = fastfloor(nz); - w0 = fastfloor(nw); + x0 = fastfloor(x); + y0 = fastfloor(y); + z0 = fastfloor(z); + w0 = fastfloor(w); ii = x0 & 255; jj = y0 & 255; @@ -64,10 +64,10 @@ T NzPerlin4D::GetValue(T x, T y, T z, T w, T res) gi14 = perm[ii + perm[jj + 1 + perm[kk + 1 + perm[ll + 1]]]] & 31; gi15 = perm[ii + 1 + perm[jj + 1 + perm[kk + 1 + perm[ll + 1]]]] & 31; - temp.x = nx-x0; - temp.y = ny-y0; - temp.z = nz-z0; - temp.w = nw-w0; + temp.x = x-x0; + temp.y = y-y0; + temp.z = z-z0; + temp.w = w-w0; Cx = temp.x * temp.x * temp.x * (temp.x * (temp.x * 6 - 15) + 10); Cy = temp.y * temp.y * temp.y * (temp.y * (temp.y * 6 - 15) + 10); @@ -76,55 +76,55 @@ T NzPerlin4D::GetValue(T x, T y, T z, T w, T res) s[0] = gradient4[gi0][0]*temp.x + gradient4[gi0][1]*temp.y + gradient4[gi0][2]*temp.z + gradient4[gi0][3]*temp.w; - temp.x = nx-(x0+1); + temp.x = x-(x0+1); t[0] = gradient4[gi1][0]*temp.x + gradient4[gi1][1]*temp.y + gradient4[gi1][2]*temp.z + gradient4[gi1][3]*temp.w; - temp.y = ny-(y0+1); + temp.y = y-(y0+1); v[0] = gradient4[gi3][0]*temp.x + gradient4[gi3][1]*temp.y + gradient4[gi3][2]*temp.z + gradient4[gi3][3]*temp.w; - temp.x = nx-x0; + temp.x = x-x0; u[0] = gradient4[gi2][0]*temp.x + gradient4[gi2][1]*temp.y + gradient4[gi2][2]*temp.z + gradient4[gi2][3]*temp.w; - temp.y = ny-y0; - temp.z = nz-(z0+1); + temp.y = y-y0; + temp.z = z-(z0+1); s[1] = gradient4[gi4][0]*temp.x + gradient4[gi4][1]*temp.y + gradient4[gi4][2]*temp.z + gradient4[gi4][3]*temp.w; - temp.x = nx-(x0+1); + temp.x = x-(x0+1); t[1] = gradient4[gi5][0]*temp.x + gradient4[gi5][1]*temp.y + gradient4[gi5][2]*temp.z + gradient4[gi5][3]*temp.w; - temp.y = ny-(y0+1); + temp.y = y-(y0+1); v[1] = gradient4[gi7][0]*temp.x + gradient4[gi7][1]*temp.y + gradient4[gi7][2]*temp.z + gradient4[gi7][3]*temp.w; - temp.x = nx-x0; + temp.x = x-x0; u[1] = gradient4[gi6][0]*temp.x + gradient4[gi6][1]*temp.y + gradient4[gi6][2]*temp.z + gradient4[gi6][3]*temp.w; - temp.y = ny-y0; - temp.z = nz-z0; - temp.w = nw-(w0+1); + temp.y = y-y0; + temp.z = z-z0; + temp.w = w-(w0+1); s[2] = gradient4[gi8][0]*temp.x + gradient4[gi8][1]*temp.y + gradient4[gi8][2]*temp.z + gradient4[gi8][3]*temp.w; - temp.x = nx-(x0+1); + temp.x = x-(x0+1); t[2] = gradient4[gi9][0]*temp.x + gradient4[gi9][1]*temp.y + gradient4[gi9][2]*temp.z + gradient4[gi9][3]*temp.w; - temp.y = ny-(y0+1); + temp.y = y-(y0+1); v[2] = gradient4[gi11][0]*temp.x + gradient4[gi11][1]*temp.y + gradient4[gi11][2]*temp.z + gradient4[gi11][3]*temp.w; - temp.x = nx-x0; + temp.x = x-x0; u[2] = gradient4[gi10][0]*temp.x + gradient4[gi10][1]*temp.y + gradient4[gi10][2]*temp.z + gradient4[gi10][3]*temp.w; - temp.y = ny-y0; - temp.z = nz-(z0+1); + temp.y = y-y0; + temp.z = z-(z0+1); s[3] = gradient4[gi12][0]*temp.x + gradient4[gi12][1]*temp.y + gradient4[gi12][2]*temp.z + gradient4[gi12][3]*temp.w; - temp.x = nx-(x0+1); + temp.x = x-(x0+1); t[3] = gradient4[gi13][0]*temp.x + gradient4[gi13][1]*temp.y + gradient4[gi13][2]*temp.z + gradient4[gi13][3]*temp.w; - temp.y = ny-(y0+1); + temp.y = y-(y0+1); v[3] = gradient4[gi15][0]*temp.x + gradient4[gi15][1]*temp.y + gradient4[gi15][2]*temp.z + gradient4[gi15][3]*temp.w; - temp.x = nx-x0; + temp.x = x-x0; u[3] = gradient4[gi14][0]*temp.x + gradient4[gi14][1]*temp.y + gradient4[gi14][2]*temp.z + gradient4[gi14][3]*temp.w; Li1 = s[0] + Cx*(t[0]-s[0]); diff --git a/include/Nazara/Noise/Simplex2D.hpp b/include/Nazara/Noise/Simplex2D.hpp index 78d896f7d..0f2f5ac62 100644 --- a/include/Nazara/Noise/Simplex2D.hpp +++ b/include/Nazara/Noise/Simplex2D.hpp @@ -9,13 +9,14 @@ #include #include +#include #include -template class NAZARA_API NzSimplex2D : public NzNoiseBase +template class NAZARA_API NzSimplex2D : public NzAbstract2DNoise, public NzNoiseBase { public: NzSimplex2D(); - T GetValue(T x, T y, T res); + T GetValue(T x, T y, T resolution); ~NzSimplex2D() = default; protected: private: diff --git a/include/Nazara/Noise/Simplex2D.inl b/include/Nazara/Noise/Simplex2D.inl index 3d019fd54..0ce8d982f 100644 --- a/include/Nazara/Noise/Simplex2D.inl +++ b/include/Nazara/Noise/Simplex2D.inl @@ -21,10 +21,10 @@ NzSimplex2D::NzSimplex2D() } template -T NzSimplex2D::GetValue(T x, T y, T res) +T NzSimplex2D::GetValue(T x, T y, T resolution) { - x /= res; - y /= res; + x *= resolution; + y *= resolution; sum = (x + y) * SkewCoeff2D; skewedCubeOrigin.x = fastfloor(x + sum); diff --git a/include/Nazara/Noise/Simplex3D.hpp b/include/Nazara/Noise/Simplex3D.hpp index 399705072..ebb2ae1a1 100644 --- a/include/Nazara/Noise/Simplex3D.hpp +++ b/include/Nazara/Noise/Simplex3D.hpp @@ -9,13 +9,14 @@ #include #include +#include #include -template class NAZARA_API NzSimplex3D : public NzNoiseBase +template class NAZARA_API NzSimplex3D : public NzAbstract3DNoise, public NzNoiseBase { public: NzSimplex3D(); - T GetValue(T x, T y, T z, T res); + T GetValue(T x, T y, T z, T resolution); ~NzSimplex3D() = default; protected: private: diff --git a/include/Nazara/Noise/Simplex3D.inl b/include/Nazara/Noise/Simplex3D.inl index d0bd3bf0d..8a8ad7e65 100644 --- a/include/Nazara/Noise/Simplex3D.inl +++ b/include/Nazara/Noise/Simplex3D.inl @@ -22,11 +22,11 @@ NzSimplex3D::NzSimplex3D() } template -T NzSimplex3D::GetValue(T x, T y, T z, T res) +T NzSimplex3D::GetValue(T x, T y, T z, T resolution) { - x /= res; - y /= res; - z /= res; + x *= resolution; + y *= resolution; + z *= resolution; sum = (x + y + z) * SkewCoeff3D; skewedCubeOrigin.x = fastfloor(x + sum); diff --git a/include/Nazara/Noise/Simplex4D.hpp b/include/Nazara/Noise/Simplex4D.hpp index f932d212b..be5c9b7bd 100644 --- a/include/Nazara/Noise/Simplex4D.hpp +++ b/include/Nazara/Noise/Simplex4D.hpp @@ -9,13 +9,14 @@ #include #include +#include #include -template class NAZARA_API NzSimplex4D : public NzNoiseBase +template class NAZARA_API NzSimplex4D : public NzAbstract4DNoise, public NzNoiseBase { public: NzSimplex4D(); - T GetValue(T x, T y, T z, T w, T res); + T GetValue(T x, T y, T z, T w, T resolution); ~NzSimplex4D() = default; protected: private: diff --git a/include/Nazara/Noise/Simplex4D.inl b/include/Nazara/Noise/Simplex4D.inl index 413467b85..f1abd579d 100644 --- a/include/Nazara/Noise/Simplex4D.inl +++ b/include/Nazara/Noise/Simplex4D.inl @@ -46,12 +46,12 @@ NzSimplex4D::NzSimplex4D() } template -T NzSimplex4D::GetValue(T x, T y, T z, T w, T res) +T NzSimplex4D::GetValue(T x, T y, T z, T w, T resolution) { - x /= res; - y /= res; - z /= res; - w /= res; + x *= resolution; + y *= resolution; + z *= resolution; + w *= resolution; sum = (x + y + z + w) * SkewCoeff4D; skewedCubeOrigin.x = fastfloor(x + sum); diff --git a/include/Newton/JointLibrary.h b/include/Newton/JointLibrary.h deleted file mode 100644 index df46b2300..000000000 --- a/include/Newton/JointLibrary.h +++ /dev/null @@ -1,190 +0,0 @@ -/* Copyright (c) <2009> -* -* This software is provided 'as-is', without any express or implied -* warranty. In no event will the authors be held liable for any damages -* arising from the use of this software. -* -* Permission is granted to anyone to use this software for any purpose, -* including commercial applications, and to alter it and redistribute it -* freely -*/ - -#ifndef NEWTON_CUSTOM_JOINTS_H_INCLUDED_ -#define NEWTON_CUSTOM_JOINTS_H_INCLUDED_ - - -#include "Newton.h" -//#include "CustomJointLibraryStdAfx.h" - -#ifdef _NEWTON_STATIC_LIB - #define JOINTLIBRARY_API -#else - #ifdef JOINTLIBRARY_LIB - #define JOINTLIBRARY_API - #else - #ifdef JOINTLIBRARY_EXPORTS - #define JOINTLIBRARY_API __declspec(dllexport) - #else - #define JOINTLIBRARY_API __declspec(dllimport) - #endif - #endif -#endif - - - - -#ifdef __cplusplus -extern "C" { -#endif - - // Generic joint call back and user data - typedef struct NewtonUserJoint{} NewtonUserJoint; - typedef void (*NewtonUserJointDestructorCallback) (const NewtonUserJoint* me); - typedef void (*NewtonUserJointSubmitConstraintCallback) (const NewtonUserJoint* me, dFloat timestep, int threadIndex); - - - // generic joint functions - JOINTLIBRARY_API void CustomDestroyJoint(const NewtonUserJoint *joint); - JOINTLIBRARY_API NewtonJoint* CustomGetNewtonJoint (const NewtonUserJoint *joint); - JOINTLIBRARY_API int CustomGetJointID (const NewtonUserJoint *joint); - JOINTLIBRARY_API void CustomSetJointID (const NewtonUserJoint *joint, int rttI); - JOINTLIBRARY_API const NewtonBody* CustomGetBody0 (const NewtonUserJoint *joint); - JOINTLIBRARY_API const NewtonBody* CustomGetBody1 (const NewtonUserJoint *joint); - JOINTLIBRARY_API int CustomGetBodiesCollisionState (const NewtonUserJoint *joint); - JOINTLIBRARY_API void CustomSetBodiesCollisionState (const NewtonUserJoint *joint, int state); - JOINTLIBRARY_API void* CustomGetUserData (const NewtonUserJoint *joint); - JOINTLIBRARY_API void CustomSetUserData (const NewtonUserJoint *joint, void* userData); - JOINTLIBRARY_API void CustomSetDestructorCallback (const NewtonUserJoint *joint, NewtonUserJointDestructorCallback callback); - JOINTLIBRARY_API void CustomSetSubmitContraintCallback (const NewtonUserJoint *joint, NewtonUserJointSubmitConstraintCallback callback); - - - // this is a plain blank joint that can be used by advanced users who want to make their own joints - // but that can only use languages that can only interface with C code. - // we recommend using the CPP library to make the joints and then add a C interface, but this join is here for completion - typedef void (*BlankJointGetInfo) (const NewtonUserJoint* me, NewtonJointRecord* info); - JOINTLIBRARY_API NewtonUserJoint* CustomCreateBlankJoint(int maxDof, const NewtonBody* body0, const NewtonBody* body1, BlankJointGetInfo info); - - // Kinematic control joint - JOINTLIBRARY_API NewtonUserJoint *CreateCustomKinematicController (const NewtonBody* targetBody, dFloat* attachmentPointInGlobalSpace); - JOINTLIBRARY_API void CustomKinematicControllerSetPickMode (const NewtonUserJoint *pick, int mode); - JOINTLIBRARY_API void CustomKinematicControllerSetMaxLinearFriction(const NewtonUserJoint *pick, dFloat accel); - JOINTLIBRARY_API void CustomKinematicControllerSetMaxAngularFriction(const NewtonUserJoint *pick, dFloat alpha); - JOINTLIBRARY_API void CustomKinematicControllerSetTargetPosit (const NewtonUserJoint *pick, dFloat* posit); - JOINTLIBRARY_API void CustomKinematicControllerSetTargetRotation (const NewtonUserJoint *pick, dFloat* rotation); - JOINTLIBRARY_API void CustomKinematicControllerSetTargetMatrix (const NewtonUserJoint *pick, dFloat* matrix); - JOINTLIBRARY_API void CustomKinematicControllerGetTargetMatrix (const NewtonUserJoint *pick, dFloat* matrix); - - // Generic 6 degree of Freedom Joint - JOINTLIBRARY_API NewtonUserJoint *CreateCustomJoint6DOF (const dFloat* pinsAndPivotChildFrame, const dFloat* pinsAndPivotParentFrame, const NewtonBody* child, const NewtonBody* parent); - JOINTLIBRARY_API void CustomJoint6DOF_SetLinearLimits (NewtonUserJoint* customJoint6DOF, const dFloat* minLinearLimits, const dFloat* maxLinearLimits); - JOINTLIBRARY_API void CustomJoint6DOF_SetAngularLimits (NewtonUserJoint* customJoint6DOF, const dFloat* minAngularLimits, const dFloat* maxAngularLimits); - JOINTLIBRARY_API void CustomJoint6DOF_GetLinearLimits (NewtonUserJoint* customJoint6DOF, dFloat* minLinearLimits, dFloat* maxLinearLimits); - JOINTLIBRARY_API void CustomJoint6DOF_GetAngularLimits (NewtonUserJoint* customJoint6DOF, dFloat* minAngularLimits, dFloat* maxAngularLimits); - JOINTLIBRARY_API void CustomJoint6DOF_SetReverseUniversal (NewtonUserJoint* customJoint6DOF, int order); - - - // Interface for a custom BallAndSocket joint with Limits - JOINTLIBRARY_API NewtonUserJoint *CreateCustomBallAndSocket (const dFloat* pinsAndPivotChildFrame, const NewtonBody* child, const NewtonBody* parent); - JOINTLIBRARY_API void BallAndSocketSetConeAngle (NewtonUserJoint* ballJoint, dFloat angle); - JOINTLIBRARY_API void BallAndSocketSetTwistAngle (NewtonUserJoint* ballJoint, dFloat minAngle, dFloat maxAngle); - - // Interface for a custom Hinge joint with Limits - JOINTLIBRARY_API NewtonUserJoint *CreateCustomHinge (const dFloat* pinsAndPivotChildFrame, const NewtonBody* child, const NewtonBody* parent); - JOINTLIBRARY_API void HingeEnableLimits(NewtonUserJoint* hingeJoint, int state); - JOINTLIBRARY_API void HingeSetLimits (NewtonUserJoint* hingeJoint, dFloat minAngle, dFloat maxAngle); - JOINTLIBRARY_API dFloat HingeGetJointAngle (const NewtonUserJoint* hingeJoint); - JOINTLIBRARY_API void HingeGetPinAxis (const NewtonUserJoint* hingeJoint, dFloat* pin); - JOINTLIBRARY_API dFloat HingeCalculateJointOmega (const NewtonUserJoint* hingeJoint); - - // Interface for a custom Slider joint with Limits - JOINTLIBRARY_API NewtonUserJoint *CreateCustomSlider (const dFloat* pinsAndPivotChildFrame, const NewtonBody* child, const NewtonBody* parent); - JOINTLIBRARY_API void SliderEnableLimits(NewtonUserJoint* sliderJoint, int state); - JOINTLIBRARY_API void SliderSetLimits (NewtonUserJoint* sliderJoint, dFloat mindist, dFloat maxdist); - - - - // player controller functions -// typedef int (*PlayerCanPuchThisBodyCalback) (NewtonUserJoint *me, const NewtonBody* hitBody); - JOINTLIBRARY_API NewtonUserJoint *CreateCustomPlayerController (const dFloat* pins, const NewtonBody* player, dFloat maxStairStepFactor, dFloat cushion); - JOINTLIBRARY_API void CustomPlayerControllerSetVelocity (const NewtonUserJoint* playerController, dFloat forwardSpeed, dFloat sideSpeed, dFloat heading); - JOINTLIBRARY_API void CustomPlayerControllerGetVisualMaTrix (const NewtonUserJoint* playerController, dFloat* matrix); - JOINTLIBRARY_API dFloat CustomPlayerControllerGetMaxSlope (const NewtonUserJoint* playerController); - JOINTLIBRARY_API void CustomPlayerControllerSetMaxSlope (const NewtonUserJoint* playerController, dFloat maxSlopeAngleIndRadian); - JOINTLIBRARY_API const NewtonCollision* CustomPlayerControllerGetSensorShape (const NewtonUserJoint* playerController); - - -// JOINTLIBRARY_API void CustomPlayerControllerSetPushActorCallback (NewtonUserJoint* playerController, PlayerCanPuchThisBodyCalback callback); -// JOINTLIBRARY_API const NewtonCollision* CustomPlayerControllerGetVerticalSensorShape (NewtonUserJoint* playerController); -// JOINTLIBRARY_API const NewtonCollision* CustomPlayerControllerGetDynamicsSensorShape (NewtonUserJoint* playerController); - - // Multi rigid BodyCar controller functions -// JOINTLIBRARY_API NewtonUserJoint *CreateCustomMultiBodyVehicle (const dFloat* frontDir, const dFloat* upDir, const NewtonBody* carBody); -// JOINTLIBRARY_API int CustomMultiBodyVehicleAddTire (NewtonUserJoint *car, const void* userData, const dFloat* localPosition, -// dFloat mass, dFloat radius, dFloat width, -// dFloat suspensionLength, dFloat springConst, dFloat springDamper); -// JOINTLIBRARY_API int CustomMultiBodyVehicleAddSlipDifferencial (NewtonUserJoint *car, int leftTireIndex, int rightToreIndex, dFloat maxFriction); -// JOINTLIBRARY_API int CustomMultiBodyVehicleGetTiresCount(NewtonUserJoint *car); -// JOINTLIBRARY_API const NewtonBody* CustomMultiBodyVehicleGetTireBody(NewtonUserJoint *car, int tireIndex); -// JOINTLIBRARY_API dFloat CustomMultiBodyVehicleGetSpeed(NewtonUserJoint *car); -// JOINTLIBRARY_API dFloat CustomMultiBodyVehicleGetTireSteerAngle (NewtonUserJoint *car, int index); -// JOINTLIBRARY_API void CustomMultiBodyVehicleApplyTorque (NewtonUserJoint *car, int tireIndex, dFloat torque); -// JOINTLIBRARY_API void CustomMultiBodyVehicleApplySteering (NewtonUserJoint *car, int tireIndex, dFloat angle); -// JOINTLIBRARY_API void CustomMultiBodyVehicleApplyBrake (NewtonUserJoint *car, int tireIndex, dFloat brakeTorque); -// JOINTLIBRARY_API void CustomMultiBodyVehicleApplyTireRollingDrag (NewtonUserJoint *car, int index, dFloat angularDampingCoef); - - - // BEGIN k00m (Dave Gravel simple ray cast world vehicle) - typedef void (*DGRaycastVehicleTireTransformCallback) (NewtonUserJoint *car); - JOINTLIBRARY_API NewtonUserJoint *DGRaycastVehicleCreate (int maxTireCount, const dFloat* cordenateSytemInLocalSpace, NewtonBody* carBody); - JOINTLIBRARY_API void DGRaycastVehicleAddTire (NewtonUserJoint *car, void *userData, const dFloat* localPosition, dFloat mass, dFloat radius, dFloat width, dFloat friction, dFloat suspensionLength, dFloat springConst, dFloat springDamper, int castMode); - JOINTLIBRARY_API void DGRaycastVehicleSetTireTransformCallback (NewtonUserJoint *car, DGRaycastVehicleTireTransformCallback callback); - JOINTLIBRARY_API int DGRaycastVehicleGetTiresCount(NewtonUserJoint *car); - JOINTLIBRARY_API void* DGRaycastVehicleGetTiresUserData(NewtonUserJoint *car, int tireIndex); - JOINTLIBRARY_API void DGRaycastVehicleGetTireMatrix(NewtonUserJoint *car, int tireIndex, dFloat* tireMatrix); - - JOINTLIBRARY_API void DGRaycastVehicleInitNormalizeTireLateralForce(NewtonUserJoint *car, int pointsCount, dFloat* const piceSizeStepAxis, dFloat* const normalizedForceValue); - JOINTLIBRARY_API void DGRaycastVehicleInitNormalizeTireLongitudinalForce(NewtonUserJoint *car, int pointsCount, dFloat* const piceSizeStepAxis, dFloat* const normalizedForceValue); - - -// JOINTLIBRARY_API void DGRayCarGetChassisMatrixLocal(NewtonUserJoint *car, dFloat* chassisMatrix); -// JOINTLIBRARY_API void DGRayCarTireMatrix(NewtonUserJoint *car, int tire, dFloat* tireMatrix); -// JOINTLIBRARY_API void DGRayCarSuspensionMatrix(NewtonUserJoint *car, int tire, dFloat param, dFloat* SuspensionMatrix); -// JOINTLIBRARY_API const NewtonCollision* DGRayCarTireShape(NewtonUserJoint *car, int tireIndex); -// JOINTLIBRARY_API dFloat DGRaycastVehicleGetSpeed(NewtonUserJoint *car); -// JOINTLIBRARY_API void DGRaycastVehicleSetCustomTireBrake (NewtonUserJoint *car, int index, dFloat torque); -// JOINTLIBRARY_API void DGRaycastVehicleSetCustomTireTorque (NewtonUserJoint *car, int index, dFloat torque); -// JOINTLIBRARY_API void DGRaycastVehicleSetCustomTireSteerAngleForce (NewtonUserJoint *car, int index, dFloat angle, dFloat turnforce); -// JOINTLIBRARY_API dFloat DGRaycastVehicleGenerateTiresBrake (NewtonUserJoint *car, dFloat value); -// JOINTLIBRARY_API dFloat DGRaycastVehicleGenerateTiresTorque (NewtonUserJoint *car, dFloat value); -// JOINTLIBRARY_API dFloat DGRaycastVehicleGenerateTiresSteerForce (NewtonUserJoint *car, dFloat value); -// JOINTLIBRARY_API dFloat DGRaycastVehicleGenerateTiresSteerAngle (NewtonUserJoint *car, dFloat value); -// JOINTLIBRARY_API void DGRaycastVehicleSetVarTireMovePointForceFront (NewtonUserJoint *car, int index, dFloat distance); -// JOINTLIBRARY_API void DGRaycastVehicleSetVarTireMovePointForceRight (NewtonUserJoint *car, int index, dFloat distance); -// JOINTLIBRARY_API void DGRaycastVehicleSetVarTireMovePointForceUp (NewtonUserJoint *car, int index, dFloat distance); -// JOINTLIBRARY_API void DGRaycastVehicleSetVarFixDeceleration (NewtonUserJoint *car, dFloat value); -// JOINTLIBRARY_API void DGRaycastVehicleSetVarChassisRotationLimit (NewtonUserJoint *car, dFloat value); -// JOINTLIBRARY_API void DGRaycastVehicleSetVarMaxSteerAngle (NewtonUserJoint *car, dFloat value); -// JOINTLIBRARY_API void DGRaycastVehicleSetVarMaxSteerRate (NewtonUserJoint *car, dFloat value); -// JOINTLIBRARY_API void DGRaycastVehicleSetVarMaxSteerForceRate (NewtonUserJoint *car, dFloat value); -// JOINTLIBRARY_API void DGRaycastVehicleSetVarMaxSteerForce (NewtonUserJoint *car, dFloat value); -// JOINTLIBRARY_API void DGRaycastVehicleSetVarMaxSteerSpeedRestriction (NewtonUserJoint *car, dFloat value); -// JOINTLIBRARY_API void DGRaycastVehicleSetVarMaxBrakeForce (NewtonUserJoint *car, dFloat value); -// JOINTLIBRARY_API void DGRaycastVehicleSetVarMaxTorque (NewtonUserJoint *car, dFloat value); -// JOINTLIBRARY_API void DGRaycastVehicleSetVarMaxTorqueRate (NewtonUserJoint *car, dFloat value); -// JOINTLIBRARY_API void DGRaycastVehicleSetVarEngineSteerDiv (NewtonUserJoint *car, dFloat value); -// JOINTLIBRARY_API void DGRaycastVehicleSetVarTireSuspenssionHardLimit (NewtonUserJoint *car, int index, dFloat value); -// JOINTLIBRARY_API void DGRaycastVehicleSetVarTireFriction (NewtonUserJoint *car, int index, dFloat value); -// JOINTLIBRARY_API int DGRaycastVehicleGetVehicleOnAir(NewtonUserJoint *car); -// JOINTLIBRARY_API int DGRaycastVehicleGetTireOnAir(NewtonUserJoint *car, int index); -// JOINTLIBRARY_API void DGRaycastVehicleDestroy (NewtonUserJoint *car); -// END - - - - -#ifdef __cplusplus -} -#endif - - -#endif diff --git a/include/Newton/Newton.h b/include/Newton/Newton.h deleted file mode 100644 index e6fa2d770..000000000 --- a/include/Newton/Newton.h +++ /dev/null @@ -1,1059 +0,0 @@ -/* Copyright (c) <2003-2011> - * - * This software is provided 'as-is', without any express or implied - * warranty. In no event will the authors be held liable for any damages - * arising from the use of this software. - * - * Permission is granted to anyone to use this software for any purpose, - * including commercial applications, and to alter it and redistribute it - * freely, subject to the following restrictions: - * - * 1. The origin of this software must not be misrepresented; you must not - * claim that you wrote the original software. If you use this software - * in a product, an acknowledgment in the product documentation would be - * appreciated but is not required. - * - * 2. Altered source versions must be plainly marked as such, and must not be - * misrepresented as being the original software. - * - * 3. This notice may not be removed or altered from any source distribution. - */ - -#ifndef NEWTON_H__736495_6495_076__INCLUDED_ -#define NEWTON_H__736495_6495_076__INCLUDED_ - - -#define NEWTON_MAJOR_VERSION 2 -#define NEWTON_MINOR_VERSION 35 - - -#ifdef _NEWTON_STATIC_LIB - #define NEWTON_API -#else - #ifdef _NEWTON_BUILD_DLL - #ifdef _WIN32 - #define NEWTON_API __declspec (dllexport) - #else - #define NEWTON_API __attribute__ ((visibility("default"))) - #endif - #else - #ifdef _WIN32 - #define NEWTON_API __declspec (dllimport) - #else - #define NEWTON_API - #endif - #endif -#endif - - -#ifdef __USE_DOUBLE_PRECISION__ - #define dFloat double -#else - #define dFloat float -#endif - -#define dFloat64 double - - -#ifdef __cplusplus -extern "C" { -#endif - -#define NEWTON_PROFILER_WORLD_UPDATE 0 - -#define NEWTON_PROFILER_COLLISION_UPDATE 1 -#define NEWTON_PROFILER_COLLISION_UPDATE_BROAD_PHASE 2 -#define NEWTON_PROFILER_COLLISION_UPDATE_NARROW_PHASE 3 - -#define NEWTON_PROFILER_DYNAMICS_UPDATE 4 -#define NEWTON_PROFILER_DYNAMICS_CONSTRAINT_GRAPH 5 -#define NEWTON_PROFILER_DYNAMICS_SOLVE_CONSTRAINT_GRAPH 6 - -#define NEWTON_PROFILER_FORCE_CALLBACK_UPDATE 7 - - -typedef struct NewtonMesh{} NewtonMesh; -typedef struct NewtonBody{} NewtonBody; -typedef struct NewtonWorld{} NewtonWorld; -typedef struct NewtonJoint{} NewtonJoint; -typedef struct NewtonMaterial{} NewtonMaterial; -typedef struct NewtonCollision{} NewtonCollision; -typedef struct NewtonSceneProxy{} NewtonSceneProxy; -typedef struct NewtonbreakableComponentMesh{} NewtonbreakableComponentMesh; - -// typedef struct NewtonRagDoll{} NewtonRagDoll; -// typedef struct NewtonRagDollBone{} NewtonRagDollBone; - -#define SERIALIZE_ID_BOX 0 -#define SERIALIZE_ID_CONE 1 -#define SERIALIZE_ID_SPHERE 2 -#define SERIALIZE_ID_CAPSULE 3 -#define SERIALIZE_ID_CYLINDER 4 -#define SERIALIZE_ID_COMPOUND 5 -#define SERIALIZE_ID_CONVEXHULL 6 -#define SERIALIZE_ID_CONVEXMODIFIER 7 -#define SERIALIZE_ID_CHAMFERCYLINDER 8 -#define SERIALIZE_ID_TREE 9 -#define SERIALIZE_ID_NULL 10 -#define SERIALIZE_ID_HEIGHTFIELD 11 -#define SERIALIZE_ID_USERMESH 12 -#define SERIALIZE_ID_SCENE 13 -#define SERIALIZE_ID_COMPOUND_BREAKABLE 14 - -typedef struct NewtonBoxParam NewtonBoxParam; -typedef struct NewtonConeParam NewtonConeParam; -typedef struct NewtonSphereParam NewtonSphereParam; -typedef struct NewtonCapsuleParam NewtonCapsuleParam; -typedef struct NewtonCylinderParam NewtonCylinderParam; -typedef struct NewtonConvexHullParam NewtonConvexHullParam; -typedef struct NewtonCollisionTreeParam NewtonCollisionTreeParam; -typedef struct NewtonSceneCollisionParam NewtonSceneCollisionParam; -typedef struct NewtonChamferCylinderParam NewtonChamferCylinderParam; -typedef struct NewtonCompoundCollisionParam NewtonCompoundCollisionParam; -typedef struct NewtonConvexHullModifierParam NewtonConvexHullModifierParam; -typedef struct NewtonHeightFieldCollisionParam NewtonHeightFieldCollisionParam; - -typedef struct NewtonCollisionInfoRecord NewtonCollisionInfoRecord; - -struct NewtonBoxParam -{ - dFloat m_x; - dFloat m_y; - dFloat m_z; -}; - -struct NewtonSphereParam -{ - dFloat m_r0; - dFloat m_r1; - dFloat m_r2; -}; - -struct NewtonCylinderParam -{ - dFloat m_r0; - dFloat m_r1; - dFloat m_height; -}; - -struct NewtonCapsuleParam -{ - dFloat m_r0; - dFloat m_r1; - dFloat m_height; -}; - -struct NewtonConeParam -{ - dFloat m_r; - dFloat m_height; -}; - -struct NewtonChamferCylinderParam -{ - dFloat m_r; - dFloat m_height; -}; - -struct NewtonConvexHullParam -{ - int m_vertexCount; - int m_vertexStrideInBytes; - int m_faceCount; - dFloat* m_vertex; -}; - -struct NewtonConvexHullModifierParam -{ - NewtonCollision* m_chidren; -}; - - -struct NewtonCompoundCollisionParam -{ - int m_chidrenCount; - NewtonCollision** m_chidren; -}; - -struct NewtonCollisionTreeParam -{ - int m_vertexCount; - int m_indexCount; -}; - -struct NewtonHeightFieldCollisionParam -{ - int m_width; - int m_height; - int m_gridsDiagonals; - dFloat m_horizonalScale; - dFloat m_verticalScale; - unsigned short *m_elevation; - char *m_atributes; -}; - -struct NewtonSceneCollisionParam -{ - int m_childrenProxyCount; -}; - -struct NewtonCollisionInfoRecord -{ - dFloat m_offsetMatrix[4][4]; - int m_collisionType; // tag id to identify the collision primitive - int m_referenceCount; // the current reference count for this collision - int m_collisionUserID; - - union { - NewtonBoxParam m_box; - NewtonConeParam m_cone; - NewtonSphereParam m_sphere; - NewtonCapsuleParam m_capsule; - NewtonCylinderParam m_cylinder; - NewtonChamferCylinderParam m_chamferCylinder; - NewtonConvexHullParam m_convexHull; - NewtonCompoundCollisionParam m_compoundCollision; - NewtonConvexHullModifierParam m_convexHullModifier; - NewtonCollisionTreeParam m_collisionTree; - NewtonHeightFieldCollisionParam m_heightField; - NewtonSceneCollisionParam m_sceneCollision; - dFloat m_paramArray[64]; // user define collision can use this to store information - }; -}; - - -typedef struct NewtonJointRecord NewtonJointRecord; -typedef struct NewtonHingeSliderUpdateDesc NewtonHingeSliderUpdateDesc; -typedef struct NewtonUserMeshCollisionRayHitDesc NewtonUserMeshCollisionRayHitDesc; -typedef struct NewtonUserMeshCollisionCollideDesc NewtonUserMeshCollisionCollideDesc; -typedef struct NewtonWorldConvexCastReturnInfo NewtonWorldConvexCastReturnInfo; - - -struct NewtonJointRecord -{ - dFloat m_attachmenMatrix_0[4][4]; - dFloat m_attachmenMatrix_1[4][4]; - dFloat m_minLinearDof[3]; - dFloat m_maxLinearDof[3]; - dFloat m_minAngularDof[3]; - dFloat m_maxAngularDof[3]; - const NewtonBody* m_attachBody_0; - const NewtonBody* m_attachBody_1; - dFloat m_extraParameters[16]; - int m_bodiesCollisionOn; - char m_descriptionType[32]; -} ; - - - -struct NewtonUserMeshCollisionCollideDesc -{ - dFloat m_boxP0[4]; // lower bounding box of intersection query in local space - dFloat m_boxP1[4]; // upper bounding box of intersection query in local space - int m_threadNumber; // current thread executing this query - int m_faceCount; // the application should set here how many polygons intersect the query box - int m_vertexStrideInBytes; // the application should set here the size of each vertex - void* m_userData; // user data passed to the collision geometry at creation time - dFloat* m_vertex; // the application should the pointer to the vertex array. - int* m_userAttribute; // the application should set here the pointer to the user data, one for each face - int* m_faceIndexCount; // the application should set here the pointer to the vertex count of each face. - int* m_faceVertexIndex; // the application should set here the pointer index array for each vertex on a face. - NewtonBody* m_objBody; // pointer to the colliding body - NewtonBody* m_polySoupBody; // pointer to the rigid body owner of this collision tree -}; - -struct NewtonWorldConvexCastReturnInfo -{ - dFloat m_point[4]; // collision point in global space - dFloat m_normal[4]; // surface normal at collision point in global space - dFloat m_normalOnHitPoint[4]; // surface normal at the surface of the hit body, - // is the same as the normal calculated by a ray cast hitting the body at the hit point - dFloat m_penetration; // contact penetration at collision point - int m_contactID; // collision ID at contact point - const NewtonBody* m_hitBody; // body hit at contact point -}; - -struct NewtonUserMeshCollisionRayHitDesc -{ - dFloat m_p0[4]; // ray origin in collision local space - dFloat m_p1[4]; // ray destination in collision local space - dFloat m_normalOut[4]; // copy here the normal at the ray intersection - int m_userIdOut; // copy here a user defined id for further feedback - void* m_userData; // user data passed to the collision geometry at creation time -}; - -struct NewtonHingeSliderUpdateDesc -{ - dFloat m_accel; - dFloat m_minFriction; - dFloat m_maxFriction; - dFloat m_timestep; -} ; - - -// Newton callback functions -typedef void* (*NewtonAllocMemory) (int sizeInBytes); -typedef void (*NewtonFreeMemory) (void* const ptr, int sizeInBytes); -typedef void (*NewtonDestroyWorld) (const NewtonWorld* const newtonWorld); - -typedef unsigned (*NewtonGetTicksCountCallback) (); - -typedef void (*NewtonSerialize) (void* const serializeHandle, const void* buffer, int size); -typedef void (*NewtonDeserialize) (void* const serializeHandle, void* buffer, int size); - -// user collision callbacks -typedef void (*NewtonUserMeshCollisionDestroyCallback) (void* const userData); -typedef void (*NewtonUserMeshCollisionCollideCallback) (NewtonUserMeshCollisionCollideDesc* const collideDescData); -typedef dFloat (*NewtonUserMeshCollisionRayHitCallback) (NewtonUserMeshCollisionRayHitDesc* const lineDescData); -typedef void (*NewtonUserMeshCollisionGetCollisionInfo) (void* const userData, NewtonCollisionInfoRecord* const infoRecord); -typedef int (*NewtonUserMeshCollisionGetFacesInAABB) (void* const userData, const dFloat* const p0, const dFloat* const p1, - const dFloat** const vertexArray, int* const vertexCount, int* const vertexStrideInBytes, - const int* const indexList, int maxIndexCount, const int* const userDataList); - -typedef dFloat (*NewtonCollisionTreeRayCastCallback) (const NewtonBody* const body, const NewtonCollision* const treeCollision, dFloat interception, dFloat* normal, int faceId, void* usedData); -typedef dFloat (*NewtonHeightFieldRayCastCallback) (const NewtonBody* const body, const NewtonCollision* const heightFieldCollision, dFloat interception, int row, int col, dFloat* normal, int faceId, void* usedData); - - -// collision tree call back (obsoleted no recommended) -typedef void (*NewtonTreeCollisionCallback) (const NewtonBody* const bodyWithTreeCollision, const NewtonBody* const body, int faceID, - int vertexCount, const dFloat* const vertex, int vertexStrideInBytes); - -typedef void (*NewtonBodyDestructor) (const NewtonBody* const body); -typedef void (*NewtonApplyForceAndTorque) (const NewtonBody* const body, dFloat timestep, int threadIndex); -typedef void (*NewtonSetTransform) (const NewtonBody* const body, const dFloat* const matrix, int threadIndex); - -typedef int (*NewtonIslandUpdate) (const NewtonWorld* const newtonWorld, const void* islandHandle, int bodyCount); -typedef void (*NewtonBodyLeaveWorld) (const NewtonBody* const body, int threadIndex); -typedef void (*NewtonDestroyBodyByExeciveForce) (const NewtonBody* const body, const NewtonJoint* const contact); -typedef void (*NewtonCollisionDestructor) (const NewtonWorld* const newtonWorld, const NewtonCollision* const collision); - -typedef int (*NewtonCollisionCompoundBreakableCallback) (NewtonMesh* const mesh, void* const userData, dFloat* const planeMatrixOut); - -typedef int (*NewtonGetBuoyancyPlane) (const int collisionID, void* const context, const dFloat* const globalSpaceMatrix, dFloat* const globalSpacePlane); -typedef unsigned (*NewtonWorldRayPrefilterCallback)(const NewtonBody* const body, const NewtonCollision* const collision, void* const userData); -typedef dFloat (*NewtonWorldRayFilterCallback)(const NewtonBody* const body, const dFloat* const hitNormal, int collisionID, void* const userData, dFloat intersectParam); - - -typedef int (*NewtonOnAABBOverlap) (const NewtonMaterial* const material, const NewtonBody* const body0, const NewtonBody* const body1, int threadIndex); -typedef void (*NewtonContactsProcess) (const NewtonJoint* const contact, dFloat timestep, int threadIndex); - -typedef void (*NewtonBodyIterator) (const NewtonBody* const body, void* const userData); -typedef void (*NewtonJointIterator) (const NewtonJoint* const joint, void* const userData); -typedef void (*NewtonCollisionIterator) (void* const userData, int vertexCount, const dFloat* const faceArray, int faceId); - -typedef void (*NewtonBallCallBack) (const NewtonJoint* const ball, dFloat timestep); -typedef unsigned (*NewtonHingeCallBack) (const NewtonJoint* const hinge, NewtonHingeSliderUpdateDesc* const desc); -typedef unsigned (*NewtonSliderCallBack) (const NewtonJoint* const slider, NewtonHingeSliderUpdateDesc* const desc); -typedef unsigned (*NewtonUniversalCallBack) (const NewtonJoint* const universal, NewtonHingeSliderUpdateDesc* const desc); -typedef unsigned (*NewtonCorkscrewCallBack) (const NewtonJoint* const corkscrew, NewtonHingeSliderUpdateDesc* const desc); - -typedef void (*NewtonUserBilateralCallBack) (const NewtonJoint* const userJoint, dFloat timestep, int threadIndex); -typedef void (*NewtonUserBilateralGetInfoCallBack) (const NewtonJoint* const userJoint, NewtonJointRecord* const info); - -typedef void (*NewtonConstraintDestructor) (const NewtonJoint*const me); - -// typedef void (*NewtonSetRagDollTransform) (const NewtonRagDollBone* const bone); -// typedef void (*NewtonBodyActivationState) (const NewtonBody* const body, unsigned state); -// typedef void (*NewtonVehicleTireUpdate) (const NewtonJoint* const vehicle, dFloat timestep); - - -// ********************************************************************************************** -// -// world control functions -// -// ********************************************************************************************** -NEWTON_API int NewtonWorldGetVersion (); -NEWTON_API int NewtonWorldFloatSize (); - -NEWTON_API int NewtonGetMemoryUsed (); -NEWTON_API void NewtonSetMemorySystem (NewtonAllocMemory malloc, NewtonFreeMemory mfree); - -NEWTON_API NewtonWorld* NewtonCreate (); -NEWTON_API void NewtonDestroy (const NewtonWorld* const newtonWorld); -NEWTON_API void NewtonDestroyAllBodies (const NewtonWorld* const newtonWorld); - -NEWTON_API void NewtonUpdate (const NewtonWorld* const newtonWorld, dFloat timestep); -NEWTON_API void NewtonInvalidateCache (const NewtonWorld* const newtonWorld); -NEWTON_API void NewtonCollisionUpdate (const NewtonWorld* const newtonWorld); - -NEWTON_API void NewtonSetSolverModel (const NewtonWorld* const newtonWorld, int model); -NEWTON_API void NewtonSetPlatformArchitecture (const NewtonWorld* const newtonWorld, int mode); -NEWTON_API int NewtonGetPlatformArchitecture(const NewtonWorld* const newtonWorld, char* description); -NEWTON_API void NewtonSetMultiThreadSolverOnSingleIsland (const NewtonWorld* const newtonWorld, int mode); -NEWTON_API int NewtonGetMultiThreadSolverOnSingleIsland (const NewtonWorld* const newtonWorld); - -NEWTON_API void NewtonSetPerformanceClock (const NewtonWorld* const newtonWorld, NewtonGetTicksCountCallback callback); -NEWTON_API unsigned NewtonReadPerformanceTicks (const NewtonWorld* const newtonWorld, unsigned performanceEntry); -NEWTON_API unsigned NewtonReadThreadPerformanceTicks (const NewtonWorld* newtonWorld, unsigned threadIndex); - -NEWTON_API void NewtonWorldCriticalSectionLock (const NewtonWorld* const newtonWorld); -NEWTON_API void NewtonWorldCriticalSectionUnlock (const NewtonWorld* const newtonWorld); -NEWTON_API void NewtonSetThreadsCount (const NewtonWorld* const newtonWorld, int threads); -NEWTON_API int NewtonGetThreadsCount(const NewtonWorld* const newtonWorld); -NEWTON_API int NewtonGetMaxThreadsCount(const NewtonWorld* const newtonWorld); - -NEWTON_API void NewtonSetFrictionModel (const NewtonWorld* const newtonWorld, int model); -NEWTON_API void NewtonSetMinimumFrameRate (const NewtonWorld* const newtonWorld, dFloat frameRate); -NEWTON_API void NewtonSetBodyLeaveWorldEvent (const NewtonWorld* const newtonWorld, NewtonBodyLeaveWorld callback); -NEWTON_API void NewtonSetWorldSize (const NewtonWorld* const newtonWorld, const dFloat* const minPoint, const dFloat* const maxPoint); -NEWTON_API void NewtonSetIslandUpdateEvent (const NewtonWorld* const newtonWorld, NewtonIslandUpdate islandUpdate); -NEWTON_API void NewtonSetCollisionDestructor (const NewtonWorld* const newtonWorld, NewtonCollisionDestructor callback); -NEWTON_API void NewtonSetDestroyBodyByExeciveForce (const NewtonWorld* const newtonWorld, NewtonDestroyBodyByExeciveForce callback); - - -// NEWTON_API void NewtonWorldForEachBodyDo (const NewtonWorld* const newtonWorld, NewtonBodyIterator callback); -NEWTON_API void NewtonWorldForEachJointDo (const NewtonWorld* const newtonWorld, NewtonJointIterator callback, void* const userData); -NEWTON_API void NewtonWorldForEachBodyInAABBDo (const NewtonWorld* const newtonWorld, const dFloat* const p0, const dFloat* const p1, NewtonBodyIterator callback, void* const userData); - - -NEWTON_API void NewtonWorldSetUserData (const NewtonWorld* const newtonWorld, void* const userData); -NEWTON_API void* NewtonWorldGetUserData (const NewtonWorld* const newtonWorld); -NEWTON_API void NewtonWorldSetDestructorCallBack (const NewtonWorld* const newtonWorld, NewtonDestroyWorld destructor); -NEWTON_API NewtonDestroyWorld NewtonWorldGetDestructorCallBack (const NewtonWorld* const newtonWorld); - -NEWTON_API void NewtonWorldRayCast (const NewtonWorld* const newtonWorld, const dFloat* const p0, const dFloat* const p1, NewtonWorldRayFilterCallback filter, void* const userData, - NewtonWorldRayPrefilterCallback prefilter); -NEWTON_API int NewtonWorldConvexCast (const NewtonWorld* const newtonWorld, const dFloat* const matrix, const dFloat* const target, const NewtonCollision* shape, dFloat* const hitParam, void* const userData, - NewtonWorldRayPrefilterCallback prefilter, NewtonWorldConvexCastReturnInfo* info, int maxContactsCount, int threadIndex); - - -// world utility functions -NEWTON_API int NewtonWorldGetBodyCount(const NewtonWorld* const newtonWorld); -NEWTON_API int NewtonWorldGetConstraintCount(const NewtonWorld* const newtonWorld); - -// NEWTON_API int NewtonGetActiveBodiesCount(); -// NEWTON_API int NewtonGetActiveConstraintsCount(); -// NEWTON_API dFloat NewtonGetGlobalScale (const NewtonWorld* const newtonWorld); - - - -// ********************************************************************************************** -// -// Simulation islands -// -// ********************************************************************************************** -NEWTON_API NewtonBody* NewtonIslandGetBody (const void* const island, int bodyIndex); -NEWTON_API void NewtonIslandGetBodyAABB (const void* const island, int bodyIndex, dFloat* const p0, dFloat* const p1); - -// ********************************************************************************************** -// -// Physics Material Section -// -// ********************************************************************************************** -NEWTON_API int NewtonMaterialCreateGroupID(const NewtonWorld* const newtonWorld); -NEWTON_API int NewtonMaterialGetDefaultGroupID(const NewtonWorld* const newtonWorld); -NEWTON_API void NewtonMaterialDestroyAllGroupID(const NewtonWorld* const newtonWorld); - -// material definitions that can not be overwritten in function callback -NEWTON_API void* NewtonMaterialGetUserData (const NewtonWorld* const newtonWorld, int id0, int id1); -NEWTON_API void NewtonMaterialSetSurfaceThickness (const NewtonWorld* const newtonWorld, int id0, int id1, dFloat thickness); -NEWTON_API void NewtonMaterialSetContinuousCollisionMode (const NewtonWorld* const newtonWorld, int id0, int id1, int state); -NEWTON_API void NewtonMaterialSetCollisionCallback (const NewtonWorld* const newtonWorld, int id0, int id1, void* const userData, - NewtonOnAABBOverlap aabbOverlap, NewtonContactsProcess process); - -NEWTON_API void NewtonMaterialSetDefaultSoftness (const NewtonWorld* const newtonWorld, int id0, int id1, dFloat value); -NEWTON_API void NewtonMaterialSetDefaultElasticity (const NewtonWorld* const newtonWorld, int id0, int id1, dFloat elasticCoef); -NEWTON_API void NewtonMaterialSetDefaultCollidable (const NewtonWorld* const newtonWorld, int id0, int id1, int state); -NEWTON_API void NewtonMaterialSetDefaultFriction (const NewtonWorld* const newtonWorld, int id0, int id1, dFloat staticFriction, dFloat kineticFriction); - -NEWTON_API NewtonMaterial* NewtonWorldGetFirstMaterial (const NewtonWorld* const newtonWorld); -NEWTON_API NewtonMaterial* NewtonWorldGetNextMaterial (const NewtonWorld* const newtonWorld, const NewtonMaterial* const material); - -NEWTON_API NewtonBody* NewtonWorldGetFirstBody (const NewtonWorld* const newtonWorld); -NEWTON_API NewtonBody* NewtonWorldGetNextBody (const NewtonWorld* const newtonWorld, const NewtonBody* const curBody); - - -// ********************************************************************************************** -// -// Physics Contact control functions -// -// ********************************************************************************************** -NEWTON_API void *NewtonMaterialGetMaterialPairUserData (const NewtonMaterial* const material); -NEWTON_API unsigned NewtonMaterialGetContactFaceAttribute (const NewtonMaterial* const material); -NEWTON_API NewtonCollision* NewtonMaterialGetBodyCollidingShape (const NewtonMaterial* const material, const NewtonBody* const body); -//NEWTON_API unsigned NewtonMaterialGetBodyCollisionID (const NewtonMaterial* const material, const NewtonBody* const body); -NEWTON_API dFloat NewtonMaterialGetContactNormalSpeed (const NewtonMaterial* const material); -NEWTON_API void NewtonMaterialGetContactForce (const NewtonMaterial* const material, NewtonBody* const body, dFloat* const force); -NEWTON_API void NewtonMaterialGetContactPositionAndNormal (const NewtonMaterial* const material, NewtonBody* const body, dFloat* const posit, dFloat* const normal); -NEWTON_API void NewtonMaterialGetContactTangentDirections (const NewtonMaterial* const material, NewtonBody* const body, dFloat* const dir0, dFloat* const dir1); -NEWTON_API dFloat NewtonMaterialGetContactTangentSpeed (const NewtonMaterial* const material, int index); - -NEWTON_API void NewtonMaterialSetContactSoftness (const NewtonMaterial* const material, dFloat softness); -NEWTON_API void NewtonMaterialSetContactElasticity (const NewtonMaterial* const material, dFloat restitution); -NEWTON_API void NewtonMaterialSetContactFrictionState (const NewtonMaterial* const material, int state, int index); -NEWTON_API void NewtonMaterialSetContactFrictionCoef (const NewtonMaterial* const material, dFloat staticFrictionCoef, dFloat kineticFrictionCoef, int index); - -NEWTON_API void NewtonMaterialSetContactNormalAcceleration (const NewtonMaterial* const material, dFloat accel); -NEWTON_API void NewtonMaterialSetContactNormalDirection (const NewtonMaterial* const material, const dFloat* const directionVector); - -NEWTON_API void NewtonMaterialSetContactTangentAcceleration (const NewtonMaterial* const material, dFloat accel, int index); -NEWTON_API void NewtonMaterialContactRotateTangentDirections (const NewtonMaterial* const material, const dFloat* const directionVector); - - - -// ********************************************************************************************** -// -// convex collision primitives creation functions -// -// ********************************************************************************************** -NEWTON_API NewtonCollision* NewtonCreateNull (const NewtonWorld* const newtonWorld); -NEWTON_API NewtonCollision* NewtonCreateSphere (const NewtonWorld* const newtonWorld, dFloat radiusX, dFloat radiusY, dFloat radiusZ, int shapeID, const dFloat* const offsetMatrix); -NEWTON_API NewtonCollision* NewtonCreateBox (const NewtonWorld* const newtonWorld, dFloat dx, dFloat dy, dFloat dz, int shapeID, const dFloat* const offsetMatrix); -NEWTON_API NewtonCollision* NewtonCreateCone (const NewtonWorld* const newtonWorld, dFloat radius, dFloat height, int shapeID, const dFloat* const offsetMatrix); -NEWTON_API NewtonCollision* NewtonCreateCapsule (const NewtonWorld* const newtonWorld, dFloat radius, dFloat height, int shapeID, const dFloat* const offsetMatrix); -NEWTON_API NewtonCollision* NewtonCreateCylinder (const NewtonWorld* const newtonWorld, dFloat radius, dFloat height, int shapeID, const dFloat* const offsetMatrix); -NEWTON_API NewtonCollision* NewtonCreateChamferCylinder (const NewtonWorld* const newtonWorld, dFloat radius, dFloat height, int shapeID, const dFloat* const offsetMatrix); -NEWTON_API NewtonCollision* NewtonCreateConvexHull (const NewtonWorld* const newtonWorld, int count, const dFloat* const vertexCloud, int strideInBytes, dFloat tolerance, int shapeID, const dFloat* const offsetMatrix); -NEWTON_API NewtonCollision* NewtonCreateConvexHullFromMesh (const NewtonWorld* const newtonWorld, const NewtonMesh* const mesh, dFloat tolerance, int shapeID); - -NEWTON_API NewtonCollision* NewtonCreateConvexHullModifier (const NewtonWorld* const newtonWorld, const NewtonCollision* const convexHullCollision, int shapeID); -NEWTON_API void NewtonConvexHullModifierGetMatrix (const NewtonCollision* const convexHullCollision, dFloat* const matrix); -NEWTON_API void NewtonConvexHullModifierSetMatrix (const NewtonCollision* const convexHullCollision, const dFloat* const matrix); - -NEWTON_API int NewtonCollisionIsTriggerVolume(const NewtonCollision* const convexCollision); -NEWTON_API void NewtonCollisionSetAsTriggerVolume(const NewtonCollision* convexCollision, int trigger); - -NEWTON_API void NewtonCollisionSetMaxBreakImpactImpulse(const NewtonCollision* const convexHullCollision, dFloat maxImpactImpulse); -NEWTON_API dFloat NewtonCollisionGetMaxBreakImpactImpulse(const NewtonCollision* const convexHullCollision); - -NEWTON_API void NewtonCollisionSetUserID (const NewtonCollision* convexCollision, unsigned id); -NEWTON_API unsigned NewtonCollisionGetUserID (const NewtonCollision* const convexCollision); - -NEWTON_API int NewtonConvexHullGetFaceIndices (const NewtonCollision* const convexHullCollision, int face, int* const faceIndices); -NEWTON_API dFloat NewtonConvexCollisionCalculateVolume (const NewtonCollision* const convexCollision); -NEWTON_API void NewtonConvexCollisionCalculateInertialMatrix (const NewtonCollision* convexCollision, dFloat* const inertia, dFloat* const origin); - - -NEWTON_API void NewtonCollisionMakeUnique (const NewtonWorld* const newtonWorld, const NewtonCollision* const collision); -NEWTON_API void NewtonReleaseCollision (const NewtonWorld* const newtonWorld, const NewtonCollision* const collision); -NEWTON_API int NewtonAddCollisionReference (const NewtonCollision* const collision); - - -// ********************************************************************************************** -// -// mass/spring/damper collision shape -// -// ********************************************************************************************** -// NEWTON_API NewtonCollision* NewtonCreateSoftShape (const NewtonWorld* const newtonWorld); -// NEWTON_API void NewtonSoftBodySetMassCount (const NewtonCollision* convexCollision, int count); -// NEWTON_API void NewtonSoftBodySetSpringCount (const NewtonCollision* convexCollision, int count); - -// NEWTON_API void NewtonSoftBodySetMass (const NewtonCollision* convexCollision, int index, dFloat mass, dFloat* position); -// NEWTON_API int NewtonSoftBodySetSpring (const NewtonCollision* convexCollision, int index, int mass0, int mass1, dFloat stiffness, dFloat damper); -// NEWTON_API int NewtonSoftBodyGetMassArray (const NewtonCollision* convexCollision, dFloat* masses, dFloat** positions); - - -// ********************************************************************************************** -// -// complex collision primitives creation functions -// -// ********************************************************************************************** -NEWTON_API NewtonCollision* NewtonCreateCompoundCollision (const NewtonWorld* const newtonWorld, int count, NewtonCollision* const collisionPrimitiveArray[], int shapeID); -NEWTON_API NewtonCollision* NewtonCreateCompoundCollisionFromMesh (const NewtonWorld* const newtonWorld, const NewtonMesh* const mesh, dFloat hullTolerance, int shapeID, int subShapeID); -//NEWTON_API NewtonCollision* NewtonCreateCompoundCollisionFromMesh(const NewtonWorld* const newtonWorld, const NewtonMesh* const mesh, int maxSubShapesCount, int shapeID, int subShapeID); - -// ********************************************************************************************** -// -// complex breakable collision primitives interface -// -// ********************************************************************************************** -// NEWTON_API NewtonCollision* NewtonCreateCompoundBreakable (const NewtonWorld* const newtonWorld, int meshCount, -// NewtonMesh* const solids[], NewtonMesh* const splitePlanes[], -// dFloat* const matrixPallete, int* const shapeIDArray, dFloat* const densities, -// int shapeID, int debriID, NewtonCollisionCompoundBreakableCallback callback, void* buildUsedData); - -NEWTON_API NewtonCollision* NewtonCreateCompoundBreakable (const NewtonWorld* const newtonWorld, int meshCount, - const NewtonMesh** const solids, const int* const shapeIDArray, - const dFloat* const densities, const int* const internalFaceMaterial, - int shapeID, int debriID, dFloat debriSeparationGap); - - -NEWTON_API void NewtonCompoundBreakableResetAnchoredPieces (const NewtonCollision* const compoundBreakable); -NEWTON_API void NewtonCompoundBreakableSetAnchoredPieces (const NewtonCollision* const compoundBreakable, int fixShapesCount, dFloat* const matrixPallete, NewtonCollision** const fixedShapesArray); - -NEWTON_API int NewtonCompoundBreakableGetVertexCount (const NewtonCollision* const compoundBreakable); -NEWTON_API void NewtonCompoundBreakableGetVertexStreams (const NewtonCollision* const compoundBreakable, int vertexStrideInByte, dFloat* const vertex, - int normalStrideInByte, dFloat* const normal, int uvStrideInByte, dFloat* const uv); - - -NEWTON_API NewtonbreakableComponentMesh* NewtonBreakableGetMainMesh (const NewtonCollision* const compoundBreakable); -NEWTON_API NewtonbreakableComponentMesh* NewtonBreakableGetFirstComponent (const NewtonCollision* const compoundBreakable); -NEWTON_API NewtonbreakableComponentMesh* NewtonBreakableGetNextComponent (const NewtonbreakableComponentMesh* const component); - -NEWTON_API void NewtonBreakableBeginDelete (const NewtonCollision* const compoundBreakable); -NEWTON_API NewtonBody* NewtonBreakableCreateDebrieBody (const NewtonCollision* const compoundBreakable, const NewtonbreakableComponentMesh* const component); -NEWTON_API void NewtonBreakableDeleteComponent (const NewtonCollision* const compoundBreakable, const NewtonbreakableComponentMesh* const component); -NEWTON_API void NewtonBreakableEndDelete (const NewtonCollision* const compoundBreakable); - - -NEWTON_API int NewtonBreakableGetComponentsInRadius (const NewtonCollision* const compoundBreakable, const dFloat* position, dFloat radius, NewtonbreakableComponentMesh** const segments, int maxCount); - -NEWTON_API void* NewtonBreakableGetFirstSegment (const NewtonbreakableComponentMesh* const breakableComponent); -NEWTON_API void* NewtonBreakableGetNextSegment (const void* const segment); - -NEWTON_API int NewtonBreakableSegmentGetMaterial (const void* const segment); -NEWTON_API int NewtonBreakableSegmentGetIndexCount (const void* const segment); -NEWTON_API int NewtonBreakableSegmentGetIndexStream (const NewtonCollision* const compoundBreakable, const NewtonbreakableComponentMesh* const meshOwner, const void* const segment, int* const index); -NEWTON_API int NewtonBreakableSegmentGetIndexStreamShort (const NewtonCollision* const compoundBreakable, const NewtonbreakableComponentMesh* const meshOwner, const void* const segment, short int* const index); - - -NEWTON_API NewtonCollision* NewtonCreateUserMeshCollision (const NewtonWorld* const newtonWorld, const dFloat* const minBox, - const dFloat* const maxBox, void* const userData, NewtonUserMeshCollisionCollideCallback collideCallback, - NewtonUserMeshCollisionRayHitCallback rayHitCallback, NewtonUserMeshCollisionDestroyCallback destroyCallback, - NewtonUserMeshCollisionGetCollisionInfo getInfoCallback, NewtonUserMeshCollisionGetFacesInAABB facesInAABBCallback, int shapeID); - - -NEWTON_API NewtonCollision* NewtonCreateSceneCollision (const NewtonWorld* const newtonWorld, int shapeID); -NEWTON_API NewtonSceneProxy* NewtonSceneCollisionCreateProxy (NewtonCollision* const scene, NewtonCollision* const collision, const dFloat* const matrix); - -NEWTON_API void NewtonSceneCollisionDestroyProxy (NewtonCollision* const scene, NewtonSceneProxy* Proxy); -NEWTON_API void NewtonSceneProxySetMatrix (NewtonSceneProxy* const proxy, const dFloat* matrix); -NEWTON_API void NewtonSceneProxyGetMatrix (NewtonSceneProxy* const proxy, dFloat* matrix); -NEWTON_API void NewtonSceneSetProxyUserData (NewtonSceneProxy* const proxy, void* userData); -NEWTON_API void* NewtonSceneGetProxyUserData (NewtonSceneProxy* const proxy); - -NEWTON_API NewtonSceneProxy* NewtonSceneGetFirstProxy (NewtonCollision* const scene); -NEWTON_API NewtonSceneProxy* NewtonSceneGetNextProxy (NewtonCollision* const scene, NewtonSceneProxy* const proxy); - -NEWTON_API void NewtonSceneCollisionOptimize (NewtonCollision* scene); - -// *********************************************************************************************************** -// -// Collision serialization functions -// -// *********************************************************************************************************** -NEWTON_API NewtonCollision* NewtonCreateCollisionFromSerialization (const NewtonWorld* const newtonWorld, NewtonDeserialize deserializeFunction, void* const serializeHandle); -NEWTON_API void NewtonCollisionSerialize (const NewtonWorld* const newtonWorld, const NewtonCollision* const collision, NewtonSerialize serializeFunction, void* const serializeHandle); -NEWTON_API void NewtonCollisionGetInfo (const NewtonCollision* const collision, NewtonCollisionInfoRecord* const collisionInfo); - -// ********************************************************************************************** -// -// Static collision shapes functions -// -// ********************************************************************************************** -NEWTON_API NewtonCollision* NewtonCreateHeightFieldCollision (const NewtonWorld* const newtonWorld, int width, int height, int gridsDiagonals, - const unsigned short* const elevationMap, const char* const attributeMap, - dFloat horizontalScale, dFloat verticalScale, int shapeID); -NEWTON_API void NewtonHeightFieldSetUserRayCastCallback (const NewtonCollision* const treeCollision, NewtonHeightFieldRayCastCallback rayHitCallback); - - -NEWTON_API NewtonCollision* NewtonCreateTreeCollision (const NewtonWorld* const newtonWorld, int shapeID); -NEWTON_API NewtonCollision* NewtonCreateTreeCollisionFromMesh (const NewtonWorld* const newtonWorld, const NewtonMesh* const mesh, int shapeID); - -NEWTON_API void NewtonTreeCollisionSetUserRayCastCallback (const NewtonCollision* const treeCollision, NewtonCollisionTreeRayCastCallback rayHitCallback); - -NEWTON_API void NewtonTreeCollisionBeginBuild (const NewtonCollision* treeCollision); -NEWTON_API void NewtonTreeCollisionAddFace (const NewtonCollision* const treeCollision, int vertexCount, const dFloat* const vertexPtr, int strideInBytes, int faceAttribute); -NEWTON_API void NewtonTreeCollisionEndBuild (const NewtonCollision* const treeCollision, int optimize); - -NEWTON_API int NewtonTreeCollisionGetFaceAtribute (const NewtonCollision* const treeCollision, const int* const faceIndexArray); -NEWTON_API void NewtonTreeCollisionSetFaceAtribute (const NewtonCollision* const treeCollision, const int* const faceIndexArray, int attribute); -NEWTON_API int NewtonTreeCollisionGetVertexListIndexListInAABB (const NewtonCollision* const treeCollision, const dFloat* const p0, const dFloat* const p1, const dFloat** const vertexArray, int* const vertexCount, int* const vertexStrideInBytes, const int* const indexList, int maxIndexCount, const int* const faceAttribute); - - -NEWTON_API void NewtonStaticCollisionSetDebugCallback (const NewtonCollision* const staticCollision, NewtonTreeCollisionCallback userCallback); - -// ********************************************************************************************** -// -// General purpose collision library functions -// -// ********************************************************************************************** -NEWTON_API int NewtonCollisionPointDistance (const NewtonWorld* const newtonWorld, const dFloat* const point, - const NewtonCollision* const collision, const dFloat* const matrix, dFloat* const contact, dFloat* const normal, int threadIndex); - -NEWTON_API int NewtonCollisionClosestPoint (const NewtonWorld* const newtonWorld, - const NewtonCollision* const collisionA, const dFloat* const matrixA, const NewtonCollision* const collisionB, const dFloat* const matrixB, - dFloat* const contactA, dFloat* const contactB, dFloat* const normalAB, int threadIndex); - -NEWTON_API int NewtonCollisionCollide (const NewtonWorld* const newtonWorld, int maxSize, - const NewtonCollision* const collisionA, const dFloat* const matrixA, - const NewtonCollision* const collisionB, const dFloat* const matrixB, - dFloat* const contacts, dFloat* const normals, dFloat* const penetration, int threadIndex); - -NEWTON_API int NewtonCollisionCollideContinue (const NewtonWorld* const newtonWorld, int maxSize, const dFloat timestep, - const NewtonCollision* const collisionA, const dFloat* const matrixA, const dFloat* const velocA, const dFloat* omegaA, - const NewtonCollision* const collisionB, const dFloat* const matrixB, const dFloat* const velocB, const dFloat* const omegaB, - dFloat* const timeOfImpact, dFloat* const contacts, dFloat* const normals, dFloat* const penetration, int threadIndex); - -NEWTON_API void NewtonCollisionSupportVertex (const NewtonCollision* const collision, const dFloat* const dir, dFloat* const vertex); -NEWTON_API dFloat NewtonCollisionRayCast (const NewtonCollision* const collision, const dFloat* const p0, const dFloat* const p1, dFloat* const normal, int* const attribute); -NEWTON_API void NewtonCollisionCalculateAABB (const NewtonCollision* const collision, const dFloat* const matrix, dFloat* const p0, dFloat* const p1); -NEWTON_API void NewtonCollisionForEachPolygonDo (const NewtonCollision* const collision, const dFloat* const matrix, NewtonCollisionIterator callback, void* const userData); - - -// ********************************************************************************************** -// -// transforms utility functions -// -// ********************************************************************************************** -NEWTON_API void NewtonGetEulerAngle (const dFloat* const matrix, dFloat* const eulersAngles); -NEWTON_API void NewtonSetEulerAngle (const dFloat* const eulersAngles, dFloat* const matrix); -NEWTON_API dFloat NewtonCalculateSpringDamperAcceleration (dFloat dt, dFloat ks, dFloat x, dFloat kd, dFloat s); - -// ********************************************************************************************** -// -// body manipulation functions -// -// ********************************************************************************************** -NEWTON_API NewtonBody* NewtonCreateBody (const NewtonWorld* const newtonWorld, const NewtonCollision* const collision, const dFloat* const matrix); -NEWTON_API void NewtonDestroyBody(const NewtonWorld* const newtonWorld, const NewtonBody* const body); - -NEWTON_API void NewtonBodyAddForce (const NewtonBody* const body, const dFloat* const force); -NEWTON_API void NewtonBodyAddTorque (const NewtonBody* const body, const dFloat* const torque); -NEWTON_API void NewtonBodyCalculateInverseDynamicsForce (const NewtonBody* const body, dFloat timestep, const dFloat* const desiredVeloc, dFloat* const forceOut); - -NEWTON_API void NewtonBodySetMatrix (const NewtonBody* const body, const dFloat* const matrix); -NEWTON_API void NewtonBodySetMatrixRecursive (const NewtonBody* const body, const dFloat* const matrix); -NEWTON_API void NewtonBodySetMassMatrix (const NewtonBody* const body, dFloat mass, dFloat Ixx, dFloat Iyy, dFloat Izz); -NEWTON_API void NewtonBodySetMaterialGroupID (const NewtonBody* const body, int id); -NEWTON_API void NewtonBodySetContinuousCollisionMode (const NewtonBody* const body, unsigned state); -NEWTON_API void NewtonBodySetJointRecursiveCollision (const NewtonBody* const body, unsigned state); -NEWTON_API void NewtonBodySetOmega (const NewtonBody* const body, const dFloat* const omega); -NEWTON_API void NewtonBodySetVelocity (const NewtonBody* const body, const dFloat* const velocity); -NEWTON_API void NewtonBodySetForce (const NewtonBody* const body, const dFloat* const force); -NEWTON_API void NewtonBodySetTorque (const NewtonBody* const body, const dFloat* const torque); - -NEWTON_API void NewtonBodySetCentreOfMass (const NewtonBody* const body, const dFloat* const com); -NEWTON_API void NewtonBodySetLinearDamping (const NewtonBody* const body, dFloat linearDamp); -NEWTON_API void NewtonBodySetAngularDamping (const NewtonBody* const body, const dFloat* const angularDamp); -NEWTON_API void NewtonBodySetUserData (const NewtonBody* const body, void* const userData); -NEWTON_API void NewtonBodySetCollision (const NewtonBody* const body, const NewtonCollision* const collision); - - - -NEWTON_API int NewtonBodyGetSleepState (const NewtonBody* const body); -NEWTON_API int NewtonBodyGetAutoSleep (const NewtonBody* const body); -NEWTON_API void NewtonBodySetAutoSleep (const NewtonBody* const body, int state); - -NEWTON_API int NewtonBodyGetFreezeState(const NewtonBody* const body); -NEWTON_API void NewtonBodySetFreezeState (const NewtonBody* const body, int state); - - -// NEWTON_API void NewtonBodySetAutoFreeze(const NewtonBody* const body, int state); -// NEWTON_API void NewtonBodyCoriolisForcesMode (const NewtonBody* const body, int mode); -// NEWTON_API void NewtonBodySetGyroscopicForcesMode (const NewtonBody* const body, int mode); -// NEWTON_API int NewtonBodyGetGyroscopicForcesMode (const NewtonBody* const body); -// NEWTON_API int NewtonBodyGetFreezeState (const NewtonBody* const body); -// NEWTON_API void NewtonBodySetFreezeState (const NewtonBody* const body, int state); -// NEWTON_API void NewtonBodyGetFreezeTreshold (const NewtonBody* const body, dFloat* freezeSpeed2, dFloat* freezeOmega2); -// NEWTON_API void NewtonBodySetFreezeTreshold (const NewtonBody* const body, dFloat freezeSpeed2, dFloat freezeOmega2, int framesCount); -// NEWTON_API void NewtonBodySetAutoactiveCallback (const NewtonBody* const body, NewtonBodyActivationState callback); - - -NEWTON_API void NewtonBodySetDestructorCallback (const NewtonBody* const body, NewtonBodyDestructor callback); - -NEWTON_API void NewtonBodySetTransformCallback (const NewtonBody* const body, NewtonSetTransform callback); -NEWTON_API NewtonSetTransform NewtonBodyGetTransformCallback (const NewtonBody* const body); - -NEWTON_API void NewtonBodySetForceAndTorqueCallback (const NewtonBody* const body, NewtonApplyForceAndTorque callback); -NEWTON_API NewtonApplyForceAndTorque NewtonBodyGetForceAndTorqueCallback (const NewtonBody* const body); -NEWTON_API void* NewtonBodyGetUserData (const NewtonBody* const body); -NEWTON_API NewtonWorld* NewtonBodyGetWorld (const NewtonBody* const body); -NEWTON_API NewtonCollision* NewtonBodyGetCollision (const NewtonBody* const body); -NEWTON_API int NewtonBodyGetMaterialGroupID (const NewtonBody* const body); - -NEWTON_API int NewtonBodyGetContinuousCollisionMode (const NewtonBody* const body); -NEWTON_API int NewtonBodyGetJointRecursiveCollision (const NewtonBody* const body); - -NEWTON_API void NewtonBodyGetMatrix(const NewtonBody* const body, dFloat* const matrix); -NEWTON_API void NewtonBodyGetRotation(const NewtonBody* const body, dFloat* const rotation); -NEWTON_API void NewtonBodyGetMassMatrix (const NewtonBody* const body, dFloat* mass, dFloat* const Ixx, dFloat* const Iyy, dFloat* const Izz); -NEWTON_API void NewtonBodyGetInvMass(const NewtonBody* const body, dFloat* const invMass, dFloat* const invIxx, dFloat* const invIyy, dFloat* const invIzz); -NEWTON_API void NewtonBodyGetOmega(const NewtonBody* const body, dFloat* const vector); -NEWTON_API void NewtonBodyGetVelocity(const NewtonBody* const body, dFloat* const vector); -NEWTON_API void NewtonBodyGetForce(const NewtonBody* const body, dFloat* const vector); -NEWTON_API void NewtonBodyGetTorque(const NewtonBody* const body, dFloat* const vector); -NEWTON_API void NewtonBodyGetForceAcc(const NewtonBody* const body, dFloat* const vector); -NEWTON_API void NewtonBodyGetTorqueAcc(const NewtonBody* const body, dFloat* const vector); -NEWTON_API void NewtonBodyGetCentreOfMass (const NewtonBody* const body, dFloat* const com); - -NEWTON_API dFloat NewtonBodyGetLinearDamping (const NewtonBody* const body); -NEWTON_API void NewtonBodyGetAngularDamping (const NewtonBody* const body, dFloat* const vector); -NEWTON_API void NewtonBodyGetAABB (const NewtonBody* const body, dFloat* const p0, dFloat* const p1); -NEWTON_API NewtonJoint* NewtonBodyGetFirstJoint (const NewtonBody* const body); -NEWTON_API NewtonJoint* NewtonBodyGetNextJoint (const NewtonBody* const body, const NewtonJoint* const joint); -NEWTON_API NewtonJoint* NewtonBodyGetFirstContactJoint (const NewtonBody* const body); -NEWTON_API NewtonJoint* NewtonBodyGetNextContactJoint (const NewtonBody* const body, const NewtonJoint* const contactJoint); - -NEWTON_API void* NewtonContactJointGetFirstContact (const NewtonJoint* const contactJoint); -NEWTON_API void* NewtonContactJointGetNextContact (const NewtonJoint* const contactJoint, void* const contact); - -NEWTON_API int NewtonContactJointGetContactCount(const NewtonJoint* const contactJoint); -NEWTON_API void NewtonContactJointRemoveContact(const NewtonJoint* const contactJoint, void* const contact); - -NEWTON_API NewtonMaterial* NewtonContactGetMaterial (const void* const contact); - - -NEWTON_API void NewtonBodyAddBuoyancyForce (const NewtonBody* const body, dFloat fluidDensity, - dFloat fluidLinearViscosity, dFloat fluidAngularViscosity, - const dFloat* const gravityVector, NewtonGetBuoyancyPlane buoyancyPlane, void* const context); - -// NEWTON_API void NewtonBodyForEachPolygonDo (const NewtonBody* const body, NewtonCollisionIterator callback); -NEWTON_API void NewtonBodyAddImpulse (const NewtonBody* const body, const dFloat* const pointDeltaVeloc, const dFloat* const pointPosit); - - -NEWTON_API void NewtonBodyApplyImpulseArray (const NewtonBody* const body, int impuleCount, int strideInByte, const dFloat* const impulseArray, const dFloat* const pointArray); - - -// ********************************************************************************************** -// -// Common joint functions -// -// ********************************************************************************************** -NEWTON_API void* NewtonJointGetUserData (const NewtonJoint* const joint); -NEWTON_API void NewtonJointSetUserData (const NewtonJoint* const joint, void* const userData); - -NEWTON_API NewtonBody* NewtonJointGetBody0 (const NewtonJoint* const joint); -NEWTON_API NewtonBody* NewtonJointGetBody1 (const NewtonJoint* const joint); - -NEWTON_API void NewtonJointGetInfo (const NewtonJoint* const joint, NewtonJointRecord* const info); -NEWTON_API int NewtonJointGetCollisionState (const NewtonJoint* const joint); -NEWTON_API void NewtonJointSetCollisionState (const NewtonJoint* const joint, int state); - -NEWTON_API dFloat NewtonJointGetStiffness (const NewtonJoint* const joint); -NEWTON_API void NewtonJointSetStiffness (const NewtonJoint* const joint, dFloat state); - -NEWTON_API void NewtonDestroyJoint(const NewtonWorld* const newtonWorld, const NewtonJoint* const joint); -NEWTON_API void NewtonJointSetDestructor (const NewtonJoint* const joint, NewtonConstraintDestructor destructor); - - - - -// ********************************************************************************************** -// -// Ball and Socket joint functions -// -// ********************************************************************************************** -NEWTON_API NewtonJoint* NewtonConstraintCreateBall (const NewtonWorld* const newtonWorld, const dFloat* pivotPoint, - const NewtonBody* const childBody, const NewtonBody* const parentBody); -NEWTON_API void NewtonBallSetUserCallback (const NewtonJoint* const ball, NewtonBallCallBack callback); -NEWTON_API void NewtonBallGetJointAngle (const NewtonJoint* const ball, dFloat* angle); -NEWTON_API void NewtonBallGetJointOmega (const NewtonJoint* const ball, dFloat* omega); -NEWTON_API void NewtonBallGetJointForce (const NewtonJoint* const ball, dFloat* const force); -NEWTON_API void NewtonBallSetConeLimits (const NewtonJoint* const ball, const dFloat* pin, dFloat maxConeAngle, dFloat maxTwistAngle); - -// ********************************************************************************************** -// -// Hinge joint functions -// -// ********************************************************************************************** -NEWTON_API NewtonJoint* NewtonConstraintCreateHinge (const NewtonWorld* const newtonWorld, - const dFloat* pivotPoint, const dFloat* pinDir, - const NewtonBody* const childBody, const NewtonBody* const parentBody); - -NEWTON_API void NewtonHingeSetUserCallback (const NewtonJoint* const hinge, NewtonHingeCallBack callback); -NEWTON_API dFloat NewtonHingeGetJointAngle (const NewtonJoint* const hinge); -NEWTON_API dFloat NewtonHingeGetJointOmega (const NewtonJoint* const hinge); -NEWTON_API void NewtonHingeGetJointForce (const NewtonJoint* const hinge, dFloat* const force); -NEWTON_API dFloat NewtonHingeCalculateStopAlpha (const NewtonJoint* const hinge, const NewtonHingeSliderUpdateDesc* const desc, dFloat angle); - -// ********************************************************************************************** -// -// Slider joint functions -// -// ********************************************************************************************** -NEWTON_API NewtonJoint* NewtonConstraintCreateSlider (const NewtonWorld* const newtonWorld, - const dFloat* pivotPoint, const dFloat* pinDir, - const NewtonBody* const childBody, const NewtonBody* const parentBody); -NEWTON_API void NewtonSliderSetUserCallback (const NewtonJoint* const slider, NewtonSliderCallBack callback); -NEWTON_API dFloat NewtonSliderGetJointPosit (const NewtonJoint* slider); -NEWTON_API dFloat NewtonSliderGetJointVeloc (const NewtonJoint* slider); -NEWTON_API void NewtonSliderGetJointForce (const NewtonJoint* const slider, dFloat* const force); -NEWTON_API dFloat NewtonSliderCalculateStopAccel (const NewtonJoint* const slider, const NewtonHingeSliderUpdateDesc* const desc, dFloat position); - - -// ********************************************************************************************** -// -// Corkscrew joint functions -// -// ********************************************************************************************** -NEWTON_API NewtonJoint* NewtonConstraintCreateCorkscrew (const NewtonWorld* const newtonWorld, - const dFloat* pivotPoint, const dFloat* pinDir, - const NewtonBody* const childBody, const NewtonBody* const parentBody); -NEWTON_API void NewtonCorkscrewSetUserCallback (const NewtonJoint* const corkscrew, NewtonCorkscrewCallBack callback); -NEWTON_API dFloat NewtonCorkscrewGetJointPosit (const NewtonJoint* const corkscrew); -NEWTON_API dFloat NewtonCorkscrewGetJointAngle (const NewtonJoint* const corkscrew); -NEWTON_API dFloat NewtonCorkscrewGetJointVeloc (const NewtonJoint* const corkscrew); -NEWTON_API dFloat NewtonCorkscrewGetJointOmega (const NewtonJoint* const corkscrew); -NEWTON_API void NewtonCorkscrewGetJointForce (const NewtonJoint* const corkscrew, dFloat* const force); -NEWTON_API dFloat NewtonCorkscrewCalculateStopAlpha (const NewtonJoint* const corkscrew, const NewtonHingeSliderUpdateDesc* const desc, dFloat angle); -NEWTON_API dFloat NewtonCorkscrewCalculateStopAccel (const NewtonJoint* const corkscrew, const NewtonHingeSliderUpdateDesc* const desc, dFloat position); - - -// ********************************************************************************************** -// -// Universal joint functions -// -// ********************************************************************************************** -NEWTON_API NewtonJoint* NewtonConstraintCreateUniversal (const NewtonWorld* const newtonWorld, - const dFloat* pivotPoint, const dFloat* pinDir0, const dFloat* pinDir1, - const NewtonBody* const childBody, const NewtonBody* const parentBody); -NEWTON_API void NewtonUniversalSetUserCallback (const NewtonJoint* const universal, NewtonUniversalCallBack callback); -NEWTON_API dFloat NewtonUniversalGetJointAngle0 (const NewtonJoint* const universal); -NEWTON_API dFloat NewtonUniversalGetJointAngle1 (const NewtonJoint* const universal); -NEWTON_API dFloat NewtonUniversalGetJointOmega0 (const NewtonJoint* const universal); -NEWTON_API dFloat NewtonUniversalGetJointOmega1 (const NewtonJoint* const universal); -NEWTON_API void NewtonUniversalGetJointForce (const NewtonJoint* const universal, dFloat* const force); -NEWTON_API dFloat NewtonUniversalCalculateStopAlpha0 (const NewtonJoint* const universal, const NewtonHingeSliderUpdateDesc* const desc, dFloat angle); -NEWTON_API dFloat NewtonUniversalCalculateStopAlpha1 (const NewtonJoint* const universal, const NewtonHingeSliderUpdateDesc* const desc, dFloat angle); - - -// ********************************************************************************************** -// -// Up vector joint functions -// -// ********************************************************************************************** -NEWTON_API NewtonJoint* NewtonConstraintCreateUpVector (const NewtonWorld* const newtonWorld, const dFloat* pinDir, const NewtonBody* const body); -NEWTON_API void NewtonUpVectorGetPin (const NewtonJoint* const upVector, dFloat *pin); -NEWTON_API void NewtonUpVectorSetPin (const NewtonJoint* const upVector, const dFloat *pin); - - -// ********************************************************************************************** -// -// User defined bilateral Joint -// -// ********************************************************************************************** -NEWTON_API NewtonJoint* NewtonConstraintCreateUserJoint (const NewtonWorld* const newtonWorld, int maxDOF, - NewtonUserBilateralCallBack callback, - NewtonUserBilateralGetInfoCallBack getInfo, - const NewtonBody* const childBody, const NewtonBody* const parentBody) ; -NEWTON_API void NewtonUserJointSetFeedbackCollectorCallback (const NewtonJoint* const joint, NewtonUserBilateralCallBack getFeedback); -NEWTON_API void NewtonUserJointAddLinearRow (const NewtonJoint* const joint, const dFloat* const pivot0, const dFloat* const pivot1, const dFloat* const dir); -NEWTON_API void NewtonUserJointAddAngularRow (const NewtonJoint* const joint, dFloat relativeAngle, const dFloat* const dir); -NEWTON_API void NewtonUserJointAddGeneralRow (const NewtonJoint* const joint, const dFloat* const jacobian0, const dFloat* const jacobian1); -NEWTON_API void NewtonUserJointSetRowMinimumFriction (const NewtonJoint* const joint, dFloat friction); -NEWTON_API void NewtonUserJointSetRowMaximumFriction (const NewtonJoint* const joint, dFloat friction); -NEWTON_API void NewtonUserJointSetRowAcceleration (const NewtonJoint* const joint, dFloat acceleration); -NEWTON_API void NewtonUserJointSetRowSpringDamperAcceleration (const NewtonJoint* const joint, dFloat springK, dFloat springD); -NEWTON_API void NewtonUserJointSetRowStiffness (const NewtonJoint* const joint, dFloat stiffness); -NEWTON_API dFloat NewtonUserJointGetRowForce (const NewtonJoint* const joint, int row); - - -// ********************************************************************************************** -// -// Mesh joint functions -// -// ********************************************************************************************** -NEWTON_API NewtonMesh* NewtonMeshCreate(const NewtonWorld* const newtonWorld); -NEWTON_API NewtonMesh* NewtonMeshCreateFromMesh(const NewtonMesh* const mesh); -NEWTON_API NewtonMesh* NewtonMeshCreateFromCollision(const NewtonCollision* const collision); -NEWTON_API NewtonMesh* NewtonMeshConvexHull (const NewtonWorld* const newtonWorld, int count, const dFloat* const vertexCloud, int strideInBytes, dFloat tolerance); -NEWTON_API NewtonMesh* NewtonMeshCreatePlane (const NewtonWorld* const newtonWorld, const dFloat* const locationMatrix, dFloat witdth, dFloat breadth, int material, const dFloat* const textureMatrix0, const dFloat* const textureMatrix1); - -NEWTON_API void NewtonMeshDestroy(const NewtonMesh* const mesh); - - NEWTON_API void NewtonMesApplyTransform (const NewtonMesh* const mesh, const dFloat* const matrix); -NEWTON_API void NewtonMeshCalculateOOBB(const NewtonMesh* const mesh, dFloat* const matrix, dFloat* const x, dFloat* const y, dFloat* const z); - -NEWTON_API void NewtonMeshCalculateVertexNormals(const NewtonMesh* const mesh, dFloat angleInRadians); -NEWTON_API void NewtonMeshApplySphericalMapping(const NewtonMesh* const mesh, int material); -NEWTON_API void NewtonMeshApplyBoxMapping(const NewtonMesh* const mesh, int front, int side, int top); -NEWTON_API void NewtonMeshApplyCylindricalMapping(const NewtonMesh* const mesh, int cylinderMaterial, int capMaterial); - -NEWTON_API int NewtonMeshIsOpenMesh (const NewtonMesh* const mesh); -NEWTON_API void NewtonMeshFixTJoints (const NewtonMesh* const mesh); - - -NEWTON_API void NewtonMeshPolygonize (const NewtonMesh* const mesh); -NEWTON_API void NewtonMeshTriangulate (const NewtonMesh* const mesh); -NEWTON_API NewtonMesh* NewtonMeshUnion (const NewtonMesh* const mesh, const NewtonMesh* const clipper, const dFloat* const clipperMatrix); -NEWTON_API NewtonMesh* NewtonMeshDifference (const NewtonMesh* const mesh, const NewtonMesh* const clipper, const dFloat* const clipperMatrix); -NEWTON_API NewtonMesh* NewtonMeshIntersection (const NewtonMesh* const mesh, const NewtonMesh* const clipper, const dFloat* const clipperMatrix); -NEWTON_API void NewtonMeshClip (const NewtonMesh* const mesh, const NewtonMesh* const clipper, const dFloat* const clipperMatrix, NewtonMesh** const topMesh, NewtonMesh** const bottomMesh); -NEWTON_API void NewtonMeshPlaneClip (const NewtonMesh* const mesh, dFloat* const planeMatrix, const dFloat* const planeTextureMatrix, int planeMaterial, NewtonMesh** const topMesh, NewtonMesh** const bottomMesh); - -NEWTON_API NewtonMesh* NewtonMeshApproximateConvexDecomposition (const NewtonMesh* const mesh, dFloat maxConcavity, int maxCount); -NEWTON_API NewtonMesh* NewtonMeshTetrahedralization (const NewtonMesh* const mesh, int internalMaterial, const dFloat* const textureMatrix); -NEWTON_API NewtonMesh* NewtonMeshVoronoiDecomposition (const NewtonMesh* const mesh, int pointCount, int pointStrideInBytes, const dFloat* const pointCloud, int internalMaterial, const dFloat* const textureMatrix); - - -NEWTON_API void NewtonRemoveUnusedVertices(const NewtonMesh* const mesh, int* const vertexRemapTable); - -NEWTON_API void NewtonMeshBeginFace(const NewtonMesh* const mesh); -NEWTON_API void NewtonMeshAddFace(const NewtonMesh* const mesh, int vertexCount, const dFloat* const vertex, int strideInBytes, int materialIndex); -NEWTON_API void NewtonMeshEndFace(const NewtonMesh* const mesh); - -NEWTON_API void NewtonMeshBuildFromVertexListIndexList(const NewtonMesh* const mesh, - int faceCount, const int* const faceIndexCount, const int* const faceMaterialIndex, - const dFloat* const vertex, int vertexStrideInBytes, const int* const vertexIndex, - const dFloat* const normal, int normalStrideInBytes, const int* const normalIndex, - const dFloat* const uv0, int uv0StrideInBytes, const int* const uv0Index, - const dFloat* const uv1, int uv1StrideInBytes, const int* const uv1Index); - - - -NEWTON_API void NewtonMeshGetVertexStreams (const NewtonMesh* const mesh, - int vertexStrideInByte, dFloat* const vertex, - int normalStrideInByte, dFloat* const normal, - int uvStrideInByte0, dFloat* const uv0, - int uvStrideInByte1, dFloat* const uv1); -NEWTON_API void NewtonMeshGetIndirectVertexStreams(const NewtonMesh* const mesh, - int vertexStrideInByte, dFloat* const vertex, int* const vertexIndices, int* const vertexCount, - int normalStrideInByte, dFloat* const normal, int* const normalIndices, int* const normalCount, - int uvStrideInByte0, dFloat* const uv0, int* const uvIndices0, int* const uvCount0, - int uvStrideInByte1, dFloat* const uv1, int* const uvIndices1, int* const uvCount1); -NEWTON_API void* NewtonMeshBeginHandle (const NewtonMesh* const mesh); -NEWTON_API void NewtonMeshEndHandle (const NewtonMesh* const mesh, void* const handle); -NEWTON_API int NewtonMeshFirstMaterial (const NewtonMesh* const mesh, void* const handle); -NEWTON_API int NewtonMeshNextMaterial (const NewtonMesh* const mesh, void* const handle, int materialId); -NEWTON_API int NewtonMeshMaterialGetMaterial (const NewtonMesh* const mesh, void* const handle, int materialId); -NEWTON_API int NewtonMeshMaterialGetIndexCount (const NewtonMesh* const mesh, void* const handle, int materialId); -NEWTON_API void NewtonMeshMaterialGetIndexStream (const NewtonMesh* const mesh, void* const handle, int materialId, int* const index); -NEWTON_API void NewtonMeshMaterialGetIndexStreamShort (const NewtonMesh* const mesh, void* const handle, int materialId, short int* const index); - -NEWTON_API NewtonMesh* NewtonMeshCreateFirstSingleSegment (const NewtonMesh* const mesh); -NEWTON_API NewtonMesh* NewtonMeshCreateNextSingleSegment (const NewtonMesh* const mesh, const NewtonMesh* const segment); - -NEWTON_API NewtonMesh* NewtonMeshCreateFirstLayer (const NewtonMesh* const mesh); -NEWTON_API NewtonMesh* NewtonMeshCreateNextLayer (const NewtonMesh* const mesh, const NewtonMesh* const segment); - - -NEWTON_API int NewtonMeshGetTotalFaceCount (const NewtonMesh* const mesh); -NEWTON_API int NewtonMeshGetTotalIndexCount (const NewtonMesh* const mesh); -NEWTON_API void NewtonMeshGetFaces (const NewtonMesh* const mesh, int* const faceIndexCount, int* const faceMaterial, void** const faceIndices); - - -NEWTON_API int NewtonMeshGetPointCount (const NewtonMesh* const mesh); -NEWTON_API int NewtonMeshGetPointStrideInByte (const NewtonMesh* const mesh); -NEWTON_API dFloat64* NewtonMeshGetPointArray (const NewtonMesh* const mesh); -NEWTON_API dFloat64* NewtonMeshGetNormalArray (const NewtonMesh* const mesh); -NEWTON_API dFloat64* NewtonMeshGetUV0Array (const NewtonMesh* const mesh); -NEWTON_API dFloat64* NewtonMeshGetUV1Array (const NewtonMesh* const mesh); - -NEWTON_API int NewtonMeshGetVertexCount (const NewtonMesh* const mesh); -NEWTON_API int NewtonMeshGetVertexStrideInByte (const NewtonMesh* const mesh); -NEWTON_API dFloat64* NewtonMeshGetVertexArray (const NewtonMesh* const mesh); - - -NEWTON_API void* NewtonMeshGetFirstVertex (const NewtonMesh* const mesh); -NEWTON_API void* NewtonMeshGetNextVertex (const NewtonMesh* const mesh, const void* const vertex); -NEWTON_API int NewtonMeshGetVertexIndex (const NewtonMesh* const mesh, const void* const vertex); - -NEWTON_API void* NewtonMeshGetFirstPoint (const NewtonMesh* const mesh); -NEWTON_API void* NewtonMeshGetNextPoint (const NewtonMesh* const mesh, const void* const point); -NEWTON_API int NewtonMeshGetPointIndex (const NewtonMesh* const mesh, const void* const point); -NEWTON_API int NewtonMeshGetVertexIndexFromPoint (const NewtonMesh* const mesh, const void* const point); - - -NEWTON_API void* NewtonMeshGetFirstEdge (const NewtonMesh* const mesh); -NEWTON_API void* NewtonMeshGetNextEdge (const NewtonMesh* const mesh, const void* const edge); -NEWTON_API void NewtonMeshGetEdgeIndices (const NewtonMesh* const mesh, const void* const edge, int* const v0, int* const v1); -//NEWTON_API void NewtonMeshGetEdgePointIndices (const NewtonMesh* const mesh, const void* const edge, int* const v0, int* const v1); - -NEWTON_API void* NewtonMeshGetFirstFace (const NewtonMesh* const mesh); -NEWTON_API void* NewtonMeshGetNextFace (const NewtonMesh* const mesh, const void* const face); -NEWTON_API int NewtonMeshIsFaceOpen (const NewtonMesh* const mesh, const void* const face); -NEWTON_API int NewtonMeshGetFaceMaterial (const NewtonMesh* const mesh, const void* const face); -NEWTON_API int NewtonMeshGetFaceIndexCount (const NewtonMesh* const mesh, const void* const face); -NEWTON_API void NewtonMeshGetFaceIndices (const NewtonMesh* const mesh, const void* const face, int* const indices); -NEWTON_API void NewtonMeshGetFacePointIndices (const NewtonMesh* const mesh, const void* const face, int* const indices); - - -#ifdef __cplusplus -} -#endif - -#endif - - - From a41a2ddcb3d67d4ec1eeb9ad8584423d4fcab564 Mon Sep 17 00:00:00 2001 From: Remi Beges Date: Sun, 30 Sep 2012 19:13:25 +0200 Subject: [PATCH 08/14] Added ability to give offset and gain to every noise (mappedNoise) + bugfixes --- include/Nazara/Noise/Abstract2DNoise.hpp | 5 ++--- include/Nazara/Noise/Abstract2DNoise.inl | 8 ++++---- include/Nazara/Noise/Abstract3DNoise.hpp | 6 +++--- include/Nazara/Noise/Abstract3DNoise.inl | 8 ++++---- include/Nazara/Noise/Abstract4DNoise.hpp | 7 +++---- include/Nazara/Noise/Abstract4DNoise.inl | 8 ++++---- include/Nazara/Noise/MappedNoiseBase.inl | 4 ++-- include/Nazara/Noise/Perlin2D.hpp | 2 +- include/Nazara/Noise/Perlin3D.hpp | 2 +- include/Nazara/Noise/Perlin3D.inl | 6 +++--- include/Nazara/Noise/Perlin4D.hpp | 2 +- include/Nazara/Noise/Simplex2D.hpp | 2 +- include/Nazara/Noise/Simplex3D.hpp | 2 +- include/Nazara/Noise/Simplex4D.hpp | 2 +- 14 files changed, 31 insertions(+), 33 deletions(-) diff --git a/include/Nazara/Noise/Abstract2DNoise.hpp b/include/Nazara/Noise/Abstract2DNoise.hpp index 819c528d3..9b69a8d3d 100644 --- a/include/Nazara/Noise/Abstract2DNoise.hpp +++ b/include/Nazara/Noise/Abstract2DNoise.hpp @@ -10,13 +10,12 @@ #include #include -template class NAZARA_API NzAbstract2DNoise : public NzMappedNoiseBase +template class NzAbstract2DNoise : public NzMappedNoiseBase { public: + virtual T GetBasicValue(T x, T y); virtual T GetMappedValue(T x, T y); virtual T GetValue(T x, T y, T resolution) = 0; - virtual T GetValue(T x, T y); - }; #include diff --git a/include/Nazara/Noise/Abstract2DNoise.inl b/include/Nazara/Noise/Abstract2DNoise.inl index 868e6fda1..98b738d36 100644 --- a/include/Nazara/Noise/Abstract2DNoise.inl +++ b/include/Nazara/Noise/Abstract2DNoise.inl @@ -9,15 +9,15 @@ #include template -T NzAbstract2DNoise::GetMappedValue(T x, T y) +T NzAbstract2DNoise::GetBasicValue(T x, T y) { - return GetValue(x,y,this->m_resolution) * this->m_gain + this->m_offset; + return this->GetValue(x,y,this->m_resolution); } template -T NzAbstract2DNoise::GetValue(T x, T y) +T NzAbstract2DNoise::GetMappedValue(T x, T y) { - return GetValue(x,y,this->m_resolution); + return (this->GetValue(x,y,this->m_resolution) + this->m_offset) * this->m_gain; } #include diff --git a/include/Nazara/Noise/Abstract3DNoise.hpp b/include/Nazara/Noise/Abstract3DNoise.hpp index 8ae002425..c921f9407 100644 --- a/include/Nazara/Noise/Abstract3DNoise.hpp +++ b/include/Nazara/Noise/Abstract3DNoise.hpp @@ -10,12 +10,12 @@ #include #include -template class NAZARA_API NzAbstract3DNoise : public NzMappedNoiseBase +template class NzAbstract3DNoise : public NzMappedNoiseBase { public: + virtual T GetBasicValue(T x, T y, T z); virtual T GetMappedValue(T x, T y, T z); - virtual T GetValue(T x, T y, T z) = 0; - virtual T GetValue(T x, T y, T z, T resolution); + virtual T GetValue(T x, T y, T z, T resolution) = 0; }; #include diff --git a/include/Nazara/Noise/Abstract3DNoise.inl b/include/Nazara/Noise/Abstract3DNoise.inl index 986fec840..cc32aa556 100644 --- a/include/Nazara/Noise/Abstract3DNoise.inl +++ b/include/Nazara/Noise/Abstract3DNoise.inl @@ -9,15 +9,15 @@ #include template -T NzAbstract3DNoise::GetMappedValue(T x, T y, T z) +T NzAbstract3DNoise::GetBasicValue(T x, T y, T z) { - return GetValue(x,y,z) * m_gain + m_offset; + return this->GetValue(x,y,z,this->m_resolution); } template -T NzAbstract3DNoise::GetValue(T x, T y, T z, T resolution) +T NzAbstract3DNoise::GetMappedValue(T x, T y, T z) { - return GetValue(x,y,z,this->m_resolution); + return (this->GetValue(x,y,z,this->m_resolution) + this->m_offset) * this->m_gain ; } #include diff --git a/include/Nazara/Noise/Abstract4DNoise.hpp b/include/Nazara/Noise/Abstract4DNoise.hpp index f2d30f0ee..6f4e24a2c 100644 --- a/include/Nazara/Noise/Abstract4DNoise.hpp +++ b/include/Nazara/Noise/Abstract4DNoise.hpp @@ -10,13 +10,12 @@ #include #include -template class NAZARA_API NzAbstract4DNoise : public NzMappedNoiseBase +template class NzAbstract4DNoise : public NzMappedNoiseBase { public: + virtual T GetBasicValue(T x, T y, T z, T w); virtual T GetMappedValue(T x, T y, T z, T w); - virtual T GetValue(T x, T y, T z, T w) = 0; - virtual T GetValue(T x, T y, T z, T w, T resolution); - + virtual T GetValue(T x, T y, T z, T w, T resolution) = 0; }; #include diff --git a/include/Nazara/Noise/Abstract4DNoise.inl b/include/Nazara/Noise/Abstract4DNoise.inl index 09cbfd0df..579938446 100644 --- a/include/Nazara/Noise/Abstract4DNoise.inl +++ b/include/Nazara/Noise/Abstract4DNoise.inl @@ -9,15 +9,15 @@ #include template -T NzAbstract4DNoise::GetMappedValue(T x, T y, T z, T w) +T NzAbstract4DNoise::GetBasicValue(T x, T y, T z, T w) { - return GetValue(x,y,z,w) * m_gain + m_offset; + return this->GetValue(x,y,z,w,this->m_resolution); } template -T NzAbstract3DNoise::GetValue(T x, T y, T z, T resolution) +T NzAbstract4DNoise::GetMappedValue(T x, T y, T z, T w) { - return GetValue(x,y,z,w,this->m_resolution); + return (this->GetValue(x,y,z,w,this->m_resolution) + this->m_offset) * this->m_gain ; } #include diff --git a/include/Nazara/Noise/MappedNoiseBase.inl b/include/Nazara/Noise/MappedNoiseBase.inl index 20cb90915..9f70dee87 100644 --- a/include/Nazara/Noise/MappedNoiseBase.inl +++ b/include/Nazara/Noise/MappedNoiseBase.inl @@ -52,11 +52,11 @@ void NzMappedNoiseBase::SetResolution(T resolution) if (NzNumberEquals(resolution, static_cast(0.0))) { NzStringStream ss; - ss << __FILE__ << ':' << __LINE__ << ": Division by zero"; + ss << __FILE__ << ':' << __LINE__ << " : resolution cannot be 0.0f"; throw std::domain_error(ss.ToString()); } - m_resolution = static_cast(1.0)/resolution; + m_resolution = resolution; } #include diff --git a/include/Nazara/Noise/Perlin2D.hpp b/include/Nazara/Noise/Perlin2D.hpp index 8109aaca3..5fc43c6a1 100644 --- a/include/Nazara/Noise/Perlin2D.hpp +++ b/include/Nazara/Noise/Perlin2D.hpp @@ -12,7 +12,7 @@ #include #include -template class NAZARA_API NzPerlin2D : public NzAbstract2DNoise, public NzNoiseBase +template class NzPerlin2D : public NzAbstract2DNoise, public NzNoiseBase { public: NzPerlin2D(); diff --git a/include/Nazara/Noise/Perlin3D.hpp b/include/Nazara/Noise/Perlin3D.hpp index f93569005..8476c1a42 100644 --- a/include/Nazara/Noise/Perlin3D.hpp +++ b/include/Nazara/Noise/Perlin3D.hpp @@ -12,7 +12,7 @@ #include #include -template class NAZARA_API NzPerlin3D : public NzAbstract3DNoise, public NzNoiseBase +template class NzPerlin3D : public NzAbstract3DNoise, public NzNoiseBase { public: NzPerlin3D(); diff --git a/include/Nazara/Noise/Perlin3D.inl b/include/Nazara/Noise/Perlin3D.inl index ec6afd286..c88af73e0 100644 --- a/include/Nazara/Noise/Perlin3D.inl +++ b/include/Nazara/Noise/Perlin3D.inl @@ -24,9 +24,9 @@ NzPerlin3D::NzPerlin3D() template T NzPerlin3D::GetValue(T x, T y, T z, T resolution) { - x *= resolution; - y *= resolution; - z *= resolution; + x /= resolution; + y /= resolution; + z /= resolution; x0 = fastfloor(x); y0 = fastfloor(y); diff --git a/include/Nazara/Noise/Perlin4D.hpp b/include/Nazara/Noise/Perlin4D.hpp index 5b4ead5a8..9d26723c6 100644 --- a/include/Nazara/Noise/Perlin4D.hpp +++ b/include/Nazara/Noise/Perlin4D.hpp @@ -12,7 +12,7 @@ #include #include -template class NAZARA_API NzPerlin4D : public NzAbstract4DNoise, public NzNoiseBase +template class NzPerlin4D : public NzAbstract4DNoise, public NzNoiseBase { public: NzPerlin4D(); diff --git a/include/Nazara/Noise/Simplex2D.hpp b/include/Nazara/Noise/Simplex2D.hpp index 0f2f5ac62..f07df9e46 100644 --- a/include/Nazara/Noise/Simplex2D.hpp +++ b/include/Nazara/Noise/Simplex2D.hpp @@ -12,7 +12,7 @@ #include #include -template class NAZARA_API NzSimplex2D : public NzAbstract2DNoise, public NzNoiseBase +template class NzSimplex2D : public NzAbstract2DNoise, public NzNoiseBase { public: NzSimplex2D(); diff --git a/include/Nazara/Noise/Simplex3D.hpp b/include/Nazara/Noise/Simplex3D.hpp index ebb2ae1a1..91b11cdd2 100644 --- a/include/Nazara/Noise/Simplex3D.hpp +++ b/include/Nazara/Noise/Simplex3D.hpp @@ -12,7 +12,7 @@ #include #include -template class NAZARA_API NzSimplex3D : public NzAbstract3DNoise, public NzNoiseBase +template class NzSimplex3D : public NzAbstract3DNoise, public NzNoiseBase { public: NzSimplex3D(); diff --git a/include/Nazara/Noise/Simplex4D.hpp b/include/Nazara/Noise/Simplex4D.hpp index be5c9b7bd..57d9f5945 100644 --- a/include/Nazara/Noise/Simplex4D.hpp +++ b/include/Nazara/Noise/Simplex4D.hpp @@ -12,7 +12,7 @@ #include #include -template class NAZARA_API NzSimplex4D : public NzAbstract4DNoise, public NzNoiseBase +template class NzSimplex4D : public NzAbstract4DNoise, public NzNoiseBase { public: NzSimplex4D(); From 3f8e3cfb60c34b45ebfc35e9aa135377cdec1bf0 Mon Sep 17 00:00:00 2001 From: Remi Beges Date: Tue, 2 Oct 2012 19:55:35 +0200 Subject: [PATCH 09/14] Modifications for the new architecture to fullfill mixer implementation requirements *Added FBM2D, first complex noise class of the new architecture *Removed NoiseMachine, because was redundant and not fitting with the new architecture *Minor changes to almost every other noise class (mostly adding 'this->') everywhere an inherited member from template base class was called from the inherited class --- include/Nazara/Noise/ComplexNoiseBase.hpp | 25 +- include/Nazara/Noise/ComplexNoiseBase.inl | 102 +++ include/Nazara/Noise/FBM2D.hpp | 33 + include/Nazara/Noise/FBM2D.inl | 70 ++ include/Nazara/Noise/MappedNoiseBase.hpp | 3 +- include/Nazara/Noise/NoiseBase.hpp | 7 + include/Nazara/Noise/NoiseMachine.hpp | 93 --- include/Nazara/Noise/Perlin2D.hpp | 4 +- include/Nazara/Noise/Perlin2D.inl | 12 +- include/Nazara/Noise/Perlin3D.hpp | 2 +- include/Nazara/Noise/Perlin3D.inl | 22 +- include/Nazara/Noise/Perlin4D.hpp | 2 +- include/Nazara/Noise/Perlin4D.inl | 40 +- include/Nazara/Noise/Simplex2D.hpp | 4 +- include/Nazara/Noise/Simplex2D.inl | 10 +- include/Nazara/Noise/Simplex3D.hpp | 2 +- include/Nazara/Noise/Simplex3D.inl | 14 +- include/Nazara/Noise/Simplex4D.hpp | 2 +- include/Nazara/Noise/Simplex4D.inl | 18 +- src/Nazara/Noise/ComplexNoiseBase.cpp | 62 -- src/Nazara/Noise/NoiseMachine.cpp | 762 ---------------------- 21 files changed, 295 insertions(+), 994 deletions(-) create mode 100644 include/Nazara/Noise/ComplexNoiseBase.inl create mode 100644 include/Nazara/Noise/FBM2D.hpp create mode 100644 include/Nazara/Noise/FBM2D.inl delete mode 100644 include/Nazara/Noise/NoiseMachine.hpp delete mode 100644 src/Nazara/Noise/ComplexNoiseBase.cpp delete mode 100644 src/Nazara/Noise/NoiseMachine.cpp diff --git a/include/Nazara/Noise/ComplexNoiseBase.hpp b/include/Nazara/Noise/ComplexNoiseBase.hpp index a9db6870e..4d15cfb10 100644 --- a/include/Nazara/Noise/ComplexNoiseBase.hpp +++ b/include/Nazara/Noise/ComplexNoiseBase.hpp @@ -8,28 +8,33 @@ #define COMPLEXNOISEBASE_HPP #include -#include -class NAZARA_API NzComplexNoiseBase : public NzNoiseBase +template +class NzComplexNoiseBase { public: NzComplexNoiseBase(); ~NzComplexNoiseBase() = default; - void SetLacunarity(float lacunarity); - void SetHurstParameter(float h); - void SetOctavesNumber(float octaves); + T GetOctaveNumber() const; + T GetLacunarity() const; + T GetHurstParameter() const; + void SetLacunarity(T lacunarity); + void SetHurstParameter(T h); + void SetOctavesNumber(T octaves); void RecomputeExponentArray(); protected: - float m_lacunarity; - float m_hurst; - float m_octaves; - float exponent_array[30]; - float m_sum; + T m_lacunarity; + T m_hurst; + T m_octaves; + T exponent_array[30]; + T m_sum; private: bool m_parametersModified; }; +#include + #endif // COMPLEXNOISEBASE_HPP diff --git a/include/Nazara/Noise/ComplexNoiseBase.inl b/include/Nazara/Noise/ComplexNoiseBase.inl new file mode 100644 index 000000000..29c77e431 --- /dev/null +++ b/include/Nazara/Noise/ComplexNoiseBase.inl @@ -0,0 +1,102 @@ +// Copyright (C) 2012 Rémi Bèges +// This file is part of the "Nazara Engine". +// For conditions of distribution and use, see copyright notice in Config.hpp + +#include +#include +#include +#include + +#include +using namespace std; + +template +NzComplexNoiseBase::NzComplexNoiseBase() +{ + m_parametersModified = true; + m_lacunarity = 5.0f; + m_hurst = 1.2f; + m_octaves = 3.0f; + + for (int i(0) ; i < m_octaves; ++i) + { + exponent_array[i] = 0; + } +} + +template +T NzComplexNoiseBase::GetLacunarity() const +{ + + return m_lacunarity; +} + +template +T NzComplexNoiseBase::GetHurstParameter() const +{ + return m_hurst; +} + +template +T NzComplexNoiseBase::GetOctaveNumber() const +{ + return m_octaves; +} + +template +void NzComplexNoiseBase::SetLacunarity(T lacunarity) +{ + // if(lacunarity != m_lacunarity) + //{ + m_lacunarity = lacunarity; + m_parametersModified = true; + //} +} + +template +void NzComplexNoiseBase::SetHurstParameter(T h) +{ + //if(h != m_hurst) + //{ + m_hurst = h; + m_parametersModified = true; + //} +} + +template +void NzComplexNoiseBase::SetOctavesNumber(T octaves) +{ + if(octaves <= 30.0f) + m_octaves = octaves; + else + m_octaves = 30.0f; + + m_parametersModified = true; + +} + +template +void NzComplexNoiseBase::RecomputeExponentArray() +{ + if(m_parametersModified) + { + cout<<"Recomputing exponent array"<(m_octaves) ; ++i) + { + + exponent_array[i] = std::pow( frequency, -m_hurst ); + cout<<"expo["< +#include +#include + +template class NzFBM2D : public NzAbstract2DNoise, public NzComplexNoiseBase +{ + public: + NzFBM2D(nzNoises source, int seed); + T GetValue(T x, T y, T resolution); + ~NzFBM2D(); + protected: + private: + NzAbstract2DNoise* m_source; + T m_value; + T m_remainder; + nzNoises m_noiseType; +}; + +typedef NzFBM2D NzFBM2Df; +typedef NzFBM2D NzFBM2Dd; + +#include + +#endif // FBM2DNOISE_HPP diff --git a/include/Nazara/Noise/FBM2D.inl b/include/Nazara/Noise/FBM2D.inl new file mode 100644 index 000000000..c91792279 --- /dev/null +++ b/include/Nazara/Noise/FBM2D.inl @@ -0,0 +1,70 @@ +// Copyright (C) 2012 Rémi Bèges +// This file is part of the "Nazara Engine". +// For conditions of distribution and use, see copyright notice in Config.hpp + +#include +#include +#include + +#include +#include + +#include +using namespace std; + +template +NzFBM2D::NzFBM2D(nzNoises source, int seed) : NzComplexNoiseBase() +{ + switch(source) + { + case PERLIN: + m_source = new NzPerlin2D; + break; + + default: + m_source = new NzSimplex2D; + break; + } + m_source->SetNewSeed(seed); + m_source->ShufflePermutationTable(); + m_noiseType = source; +} + +template +T NzFBM2D::GetValue(T x, T y, T resolution) +{ + this->RecomputeExponentArray(); + + m_value = 0.0; + + for (int i(0); i < this->m_octaves; ++i) + { + m_value += m_source->GetValue(x,y,resolution) * this->exponent_array[i]; + resolution *= this->m_lacunarity; + } + //cout<m_sum<m_octaves - static_cast(this->m_octaves); + + //if(!NzNumberEquals(remainder, static_cast(0.0))) + // m_value += remainder * Get2DSimplexNoiseValue(x,y,resolution) * exponent_array[(int)m_octaves-1]; + + //0.65 is an experimental value to make the noise stick closer to [-1 , 1] + return m_value / (this->m_sum * 0.65); +} + +template +NzFBM2D::~NzFBM2D() +{ + switch(m_noiseType) + { + case PERLIN: + delete dynamic_cast*>(m_source); + break; + + default: + delete dynamic_cast*>(m_source); + break; + } +} + +#include diff --git a/include/Nazara/Noise/MappedNoiseBase.hpp b/include/Nazara/Noise/MappedNoiseBase.hpp index d60046472..5650d1cd4 100644 --- a/include/Nazara/Noise/MappedNoiseBase.hpp +++ b/include/Nazara/Noise/MappedNoiseBase.hpp @@ -8,8 +8,9 @@ #define NAZARA_MAPPEDNOISEBASE_HPP #include +#include -template class NzMappedNoiseBase +template class NzMappedNoiseBase : public NzNoiseBase { public: NzMappedNoiseBase(); diff --git a/include/Nazara/Noise/NoiseBase.hpp b/include/Nazara/Noise/NoiseBase.hpp index 331d227df..c5999008b 100644 --- a/include/Nazara/Noise/NoiseBase.hpp +++ b/include/Nazara/Noise/NoiseBase.hpp @@ -9,6 +9,13 @@ #include +enum nzNoises +{ + PERLIN, + SIMPLEX, + CELL +}; + class NAZARA_API NzNoiseBase { public: diff --git a/include/Nazara/Noise/NoiseMachine.hpp b/include/Nazara/Noise/NoiseMachine.hpp deleted file mode 100644 index 4c221628f..000000000 --- a/include/Nazara/Noise/NoiseMachine.hpp +++ /dev/null @@ -1,93 +0,0 @@ -// Copyright (C) 2012 Rémi Bèges -// This file is part of the "Nazara Engine". -// For conditions of distribution and use, see copyright notice in Config.hpp - -#pragma once - -#ifndef NOISEMACHINE_HPP -#define NOISEMACHINE_HPP - -#include -#include -#include -#include -#include - -class NAZARA_API NzNoiseMachine : public NzComplexNoiseBase -{ - public: - NzNoiseMachine(int seed = 0); - ~NzNoiseMachine() = default; - - float Get2DPerlinNoiseValue (float x, float y, float res); - float Get3DPerlinNoiseValue (float x, float y, float z, float res); - float Get4DPerlinNoiseValue (float x, float y, float z, float w, float res); - - float Get2DSimplexNoiseValue(float x, float y, float res); - float Get3DSimplexNoiseValue(float x, float y, float z, float res); - float Get4DSimplexNoiseValue(float x, float y, float z, float w, float res); - - float Get2DCellNoiseValue(float x, float y, float res); - float Get3DCellNoiseValue(float x, float y, float z, float res); - float Get4DCellNoiseValue(float x, float y, float z, float w, float res); - - float Get2DFBMNoiseValue(float x, float y, float res); - float Get3DFBMNoiseValue(float x, float y, float z, float res); - - float Get2DHybridMultiFractalNoiseValue(float x, float y, float res); - float Get3DHybridMultiFractalNoiseValue(float x, float y, float z, float res); - - protected: - private: - - float gradient2[8][2]; - int gradient3[16][3]; - int gradient4[32][4]; - int lookupTable4D[64][4]; - - //----------------------- Common variables -------------------------------------- - int ii,jj,kk,ll; - int gi0,gi1,gi2,gi3,gi4,gi5,gi6,gi7,gi8,gi9,gi10,gi11,gi12,gi13,gi14,gi15; - - //----------------------- Simplex variables -------------------------------------- - - float n1, n2, n3, n4, n5; - NzVector4f d1,d2,d3,d4,d5,unskewedCubeOrigin,unskewedDistToOrigin; - NzVector4i off1, off2,off3,skewedCubeOrigin; - - - float c1,c2,c3,c4,c5,c6; - int c; - - float SkewCoeff2D; - float UnskewCoeff2D; - - float SkewCoeff3D; - float UnskewCoeff3D; - - float SkewCoeff4D; - float UnskewCoeff4D; - - float sum; - - //----------------------- Perlin Variables ------------------------------------- - - int x0,y0,z0,w0; - float Li1,Li2,Li3,Li4,Li5,Li6,Li7,Li8,Li9,Li10,Li11,Li12,Li13,Li14; - float s[4],t[4],u[4],v[4]; - float Cx, Cy, Cz, Cw; - NzVector4f temp; - float tmp; - - //---------------------- Complex Noise Variables -------------------------------- - - - bool first; - float value; - float remainder; - float smax; - float smin; - -}; - -#endif // NOISEMACHINE_HPP diff --git a/include/Nazara/Noise/Perlin2D.hpp b/include/Nazara/Noise/Perlin2D.hpp index 5fc43c6a1..09b0a13e2 100644 --- a/include/Nazara/Noise/Perlin2D.hpp +++ b/include/Nazara/Noise/Perlin2D.hpp @@ -12,12 +12,12 @@ #include #include -template class NzPerlin2D : public NzAbstract2DNoise, public NzNoiseBase +template class NzPerlin2D : public NzAbstract2DNoise { public: NzPerlin2D(); T GetValue(T x, T y, T resolution); - ~NzPerlin2D() = default; + virtual ~NzPerlin2D() = default; protected: private: int x0, y0; diff --git a/include/Nazara/Noise/Perlin2D.inl b/include/Nazara/Noise/Perlin2D.inl index 48b4e75b3..03ddc35db 100644 --- a/include/Nazara/Noise/Perlin2D.inl +++ b/include/Nazara/Noise/Perlin2D.inl @@ -23,16 +23,16 @@ T NzPerlin2D::GetValue(T x, T y, T resolution) x *= resolution; y *= resolution; - x0 = fastfloor(x); - y0 = fastfloor(y); + x0 = this->fastfloor(x); + y0 = this->fastfloor(y); ii = x0 & 255; jj = y0 & 255; - gi0 = perm[ii + perm[jj]] & 7; - gi1 = perm[ii + 1 + perm[jj]] & 7; - gi2 = perm[ii + perm[jj + 1]] & 7; - gi3 = perm[ii + 1 + perm[jj + 1]] & 7; + gi0 = this->perm[ii + this->perm[jj]] & 7; + gi1 = this->perm[ii + 1 + this->perm[jj]] & 7; + gi2 = this->perm[ii + this->perm[jj + 1]] & 7; + gi3 = this->perm[ii + 1 + this->perm[jj + 1]] & 7; temp.x = x-x0; temp.y = y-y0; diff --git a/include/Nazara/Noise/Perlin3D.hpp b/include/Nazara/Noise/Perlin3D.hpp index 8476c1a42..31a06b07e 100644 --- a/include/Nazara/Noise/Perlin3D.hpp +++ b/include/Nazara/Noise/Perlin3D.hpp @@ -12,7 +12,7 @@ #include #include -template class NzPerlin3D : public NzAbstract3DNoise, public NzNoiseBase +template class NzPerlin3D : public NzAbstract3DNoise { public: NzPerlin3D(); diff --git a/include/Nazara/Noise/Perlin3D.inl b/include/Nazara/Noise/Perlin3D.inl index c88af73e0..de12d431f 100644 --- a/include/Nazara/Noise/Perlin3D.inl +++ b/include/Nazara/Noise/Perlin3D.inl @@ -28,23 +28,23 @@ T NzPerlin3D::GetValue(T x, T y, T z, T resolution) y /= resolution; z /= resolution; - x0 = fastfloor(x); - y0 = fastfloor(y); - z0 = fastfloor(z); + x0 = this->fastfloor(x); + y0 = this->fastfloor(y); + z0 = this->fastfloor(z); ii = x0 & 255; jj = y0 & 255; kk = z0 & 255; - gi0 = perm[ii + perm[jj + perm[kk]]] & 15; - gi1 = perm[ii + 1 + perm[jj + perm[kk]]] & 15; - gi2 = perm[ii + perm[jj + 1 + perm[kk]]] & 15; - gi3 = perm[ii + 1 + perm[jj + 1 + perm[kk]]] & 15; + gi0 = this->perm[ii + this->perm[jj + this->perm[kk]]] & 15; + gi1 = this->perm[ii + 1 + this->perm[jj + this->perm[kk]]] & 15; + gi2 = this->perm[ii + this->perm[jj + 1 + this->perm[kk]]] & 15; + gi3 = this->perm[ii + 1 + this->perm[jj + 1 + this->perm[kk]]] & 15; - gi4 = perm[ii + perm[jj + perm[kk + 1]]] & 15; - gi5 = perm[ii + 1 + perm[jj + perm[kk + 1]]] & 15; - gi6 = perm[ii + perm[jj + 1 + perm[kk + 1]]] & 15; - gi7 = perm[ii + 1 + perm[jj + 1 + perm[kk + 1]]] & 15; + gi4 = this->perm[ii + this->perm[jj + this->perm[kk + 1]]] & 15; + gi5 = this->perm[ii + 1 + this->perm[jj + this->perm[kk + 1]]] & 15; + gi6 = this->perm[ii + this->perm[jj + 1 + this->perm[kk + 1]]] & 15; + gi7 = this->perm[ii + 1 + this->perm[jj + 1 + this->perm[kk + 1]]] & 15; temp.x = x-x0; temp.y = y-y0; diff --git a/include/Nazara/Noise/Perlin4D.hpp b/include/Nazara/Noise/Perlin4D.hpp index 9d26723c6..a09c8b41a 100644 --- a/include/Nazara/Noise/Perlin4D.hpp +++ b/include/Nazara/Noise/Perlin4D.hpp @@ -12,7 +12,7 @@ #include #include -template class NzPerlin4D : public NzAbstract4DNoise, public NzNoiseBase +template class NzPerlin4D : public NzAbstract4DNoise { public: NzPerlin4D(); diff --git a/include/Nazara/Noise/Perlin4D.inl b/include/Nazara/Noise/Perlin4D.inl index d44076542..8e3d41ab8 100644 --- a/include/Nazara/Noise/Perlin4D.inl +++ b/include/Nazara/Noise/Perlin4D.inl @@ -34,35 +34,35 @@ T NzPerlin4D::GetValue(T x, T y, T z, T w, T resolution) z *= resolution; w *= resolution; - x0 = fastfloor(x); - y0 = fastfloor(y); - z0 = fastfloor(z); - w0 = fastfloor(w); + x0 = this->fastfloor(x); + y0 = this->fastfloor(y); + z0 = this->fastfloor(z); + w0 = this->fastfloor(w); ii = x0 & 255; jj = y0 & 255; kk = z0 & 255; ll = w0 & 255; - gi0 = perm[ii + perm[jj + perm[kk + perm[ll ]]]] & 31; - gi1 = perm[ii + 1 + perm[jj + perm[kk + perm[ll ]]]] & 31; - gi2 = perm[ii + perm[jj + 1 + perm[kk + perm[ll ]]]] & 31; - gi3 = perm[ii + 1 + perm[jj + 1 + perm[kk + perm[ll ]]]] & 31; + gi0 = this->perm[ii + this->perm[jj + this->perm[kk + this->perm[ll]]]] & 31; + gi1 = this->perm[ii + 1 + this->perm[jj + this->perm[kk + this->perm[ll]]]] & 31; + gi2 = this->perm[ii + this->perm[jj + 1 + this->perm[kk + this->perm[ll]]]] & 31; + gi3 = this->perm[ii + 1 + this->perm[jj + 1 + this->perm[kk + this->perm[ll]]]] & 31; - gi4 = perm[ii + perm[jj + + perm[kk + 1 + perm[ll ]]]] & 31; - gi5 = perm[ii + 1 + perm[jj + + perm[kk + 1 + perm[ll ]]]] & 31; - gi6 = perm[ii + perm[jj + 1 + perm[kk + 1 + perm[ll ]]]] & 31; - gi7 = perm[ii + 1 + perm[jj + 1 + perm[kk + 1 + perm[ll ]]]] & 31; + gi4 = this->perm[ii + this->perm[jj + + this->perm[kk + 1 + this->perm[ll]]]] & 31; + gi5 = this->perm[ii + 1 + this->perm[jj + + this->perm[kk + 1 + this->perm[ll]]]] & 31; + gi6 = this->perm[ii + this->perm[jj + 1 + this->perm[kk + 1 + this->perm[ll]]]] & 31; + gi7 = this->perm[ii + 1 + this->perm[jj + 1 + this->perm[kk + 1 + this->perm[ll]]]] & 31; - gi8 = perm[ii + perm[jj + perm[kk + perm[ll + 1]]]] & 31; - gi9 = perm[ii + 1 + perm[jj + perm[kk + perm[ll + 1]]]] & 31; - gi10 = perm[ii + perm[jj + 1 + perm[kk + perm[ll + 1]]]] & 31; - gi11 = perm[ii + 1 + perm[jj + 1 + perm[kk + perm[ll + 1]]]] & 31; + gi8 = this->perm[ii + this->perm[jj + this->perm[kk + this->perm[ll + 1]]]] & 31; + gi9 = this->perm[ii + 1 + this->perm[jj + this->perm[kk + this->perm[ll + 1]]]] & 31; + gi10 = this->perm[ii + this->perm[jj + 1 + this->perm[kk + this->perm[ll + 1]]]] & 31; + gi11 = this->perm[ii + 1 + this->perm[jj + 1 + this->perm[kk + this->perm[ll + 1]]]] & 31; - gi12 = perm[ii + perm[jj + perm[kk + 1 + perm[ll + 1]]]] & 31; - gi13 = perm[ii + 1 + perm[jj + perm[kk + 1 + perm[ll + 1]]]] & 31; - gi14 = perm[ii + perm[jj + 1 + perm[kk + 1 + perm[ll + 1]]]] & 31; - gi15 = perm[ii + 1 + perm[jj + 1 + perm[kk + 1 + perm[ll + 1]]]] & 31; + gi12 = this->perm[ii + this->perm[jj + this->perm[kk + 1 + this->perm[ll + 1]]]] & 31; + gi13 = this->perm[ii + 1 + this->perm[jj + this->perm[kk + 1 + this->perm[ll + 1]]]] & 31; + gi14 = this->perm[ii + this->perm[jj + 1 + this->perm[kk + 1 + this->perm[ll + 1]]]] & 31; + gi15 = this->perm[ii + 1 + this->perm[jj + 1 + this->perm[kk + 1 + this->perm[ll + 1]]]] & 31; temp.x = x-x0; temp.y = y-y0; diff --git a/include/Nazara/Noise/Simplex2D.hpp b/include/Nazara/Noise/Simplex2D.hpp index f07df9e46..a61499f08 100644 --- a/include/Nazara/Noise/Simplex2D.hpp +++ b/include/Nazara/Noise/Simplex2D.hpp @@ -12,12 +12,12 @@ #include #include -template class NzSimplex2D : public NzAbstract2DNoise, public NzNoiseBase +template class NzSimplex2D : public NzAbstract2DNoise { public: NzSimplex2D(); T GetValue(T x, T y, T resolution); - ~NzSimplex2D() = default; + virtual ~NzSimplex2D() = default; protected: private: int ii,jj; diff --git a/include/Nazara/Noise/Simplex2D.inl b/include/Nazara/Noise/Simplex2D.inl index 0ce8d982f..5b8e8b483 100644 --- a/include/Nazara/Noise/Simplex2D.inl +++ b/include/Nazara/Noise/Simplex2D.inl @@ -27,8 +27,8 @@ T NzSimplex2D::GetValue(T x, T y, T resolution) y *= resolution; sum = (x + y) * SkewCoeff2D; - skewedCubeOrigin.x = fastfloor(x + sum); - skewedCubeOrigin.y = fastfloor(y + sum); + skewedCubeOrigin.x = this->fastfloor(x + sum); + skewedCubeOrigin.y = this->fastfloor(y + sum); sum = (skewedCubeOrigin.x + skewedCubeOrigin.y) * UnskewCoeff2D; unskewedCubeOrigin.x = skewedCubeOrigin.x - sum; @@ -59,9 +59,9 @@ T NzSimplex2D::GetValue(T x, T y, T resolution) ii = skewedCubeOrigin.x & 255; jj = skewedCubeOrigin.y & 255; - gi0 = perm[ii + perm[jj ]] & 7; - gi1 = perm[ii + off1.x + perm[jj + off1.y]] & 7; - gi2 = perm[ii + 1 + perm[jj + 1 ]] & 7; + gi0 = this->perm[ii + this->perm[jj ]] & 7; + gi1 = this->perm[ii + off1.x + this->perm[jj + off1.y]] & 7; + gi2 = this->perm[ii + 1 + this->perm[jj + 1 ]] & 7; c1 = 0.5 - d1.x * d1.x - d1.y * d1.y; c2 = 0.5 - d2.x * d2.x - d2.y * d2.y; diff --git a/include/Nazara/Noise/Simplex3D.hpp b/include/Nazara/Noise/Simplex3D.hpp index 91b11cdd2..725c703ba 100644 --- a/include/Nazara/Noise/Simplex3D.hpp +++ b/include/Nazara/Noise/Simplex3D.hpp @@ -12,7 +12,7 @@ #include #include -template class NzSimplex3D : public NzAbstract3DNoise, public NzNoiseBase +template class NzSimplex3D : public NzAbstract3DNoise { public: NzSimplex3D(); diff --git a/include/Nazara/Noise/Simplex3D.inl b/include/Nazara/Noise/Simplex3D.inl index 8a8ad7e65..5ed20732a 100644 --- a/include/Nazara/Noise/Simplex3D.inl +++ b/include/Nazara/Noise/Simplex3D.inl @@ -29,9 +29,9 @@ T NzSimplex3D::GetValue(T x, T y, T z, T resolution) z *= resolution; sum = (x + y + z) * SkewCoeff3D; - skewedCubeOrigin.x = fastfloor(x + sum); - skewedCubeOrigin.y = fastfloor(y + sum); - skewedCubeOrigin.z = fastfloor(z + sum); + skewedCubeOrigin.x = this->fastfloor(x + sum); + skewedCubeOrigin.y = this->fastfloor(y + sum); + skewedCubeOrigin.z = this->fastfloor(z + sum); sum = (skewedCubeOrigin.x + skewedCubeOrigin.y + skewedCubeOrigin.z) * UnskewCoeff3D; unskewedCubeOrigin.x = skewedCubeOrigin.x - sum; @@ -121,10 +121,10 @@ T NzSimplex3D::GetValue(T x, T y, T z, T resolution) jj = skewedCubeOrigin.y & 255; kk = skewedCubeOrigin.z & 255; - gi0 = perm[ii + perm[jj + perm[kk ]]] % 12; - gi1 = perm[ii + off1.x + perm[jj + off1.y + perm[kk + off1.z]]] % 12; - gi2 = perm[ii + off2.x + perm[jj + off2.y + perm[kk + off2.z]]] % 12; - gi3 = perm[ii + 1 + perm[jj + 1 + perm[kk + 1 ]]] % 12; + gi0 = this->perm[ii + this->perm[jj + this->perm[kk ]]] % 12; + gi1 = this->perm[ii + off1.x + this->perm[jj + off1.y + this->perm[kk + off1.z]]] % 12; + gi2 = this->perm[ii + off2.x + this->perm[jj + off2.y + this->perm[kk + off2.z]]] % 12; + gi3 = this->perm[ii + 1 + this->perm[jj + 1 + this->perm[kk + 1 ]]] % 12; c1 = 0.6 - d1.x * d1.x - d1.y * d1.y - d1.z * d1.z; c2 = 0.6 - d2.x * d2.x - d2.y * d2.y - d2.z * d2.z; diff --git a/include/Nazara/Noise/Simplex4D.hpp b/include/Nazara/Noise/Simplex4D.hpp index 57d9f5945..fd08e76a6 100644 --- a/include/Nazara/Noise/Simplex4D.hpp +++ b/include/Nazara/Noise/Simplex4D.hpp @@ -12,7 +12,7 @@ #include #include -template class NzSimplex4D : public NzAbstract4DNoise, public NzNoiseBase +template class NzSimplex4D : public NzAbstract4DNoise { public: NzSimplex4D(); diff --git a/include/Nazara/Noise/Simplex4D.inl b/include/Nazara/Noise/Simplex4D.inl index f1abd579d..ef022a244 100644 --- a/include/Nazara/Noise/Simplex4D.inl +++ b/include/Nazara/Noise/Simplex4D.inl @@ -54,10 +54,10 @@ T NzSimplex4D::GetValue(T x, T y, T z, T w, T resolution) w *= resolution; sum = (x + y + z + w) * SkewCoeff4D; - skewedCubeOrigin.x = fastfloor(x + sum); - skewedCubeOrigin.y = fastfloor(y + sum); - skewedCubeOrigin.z = fastfloor(z + sum); - skewedCubeOrigin.w = fastfloor(w + sum); + skewedCubeOrigin.x = this->fastfloor(x + sum); + skewedCubeOrigin.y = this->fastfloor(y + sum); + skewedCubeOrigin.z = this->fastfloor(z + sum); + skewedCubeOrigin.w = this->fastfloor(w + sum); sum = (skewedCubeOrigin.x + skewedCubeOrigin.y + skewedCubeOrigin.z + skewedCubeOrigin.w) * UnskewCoeff4D; unskewedCubeOrigin.x = skewedCubeOrigin.x - sum; @@ -120,11 +120,11 @@ T NzSimplex4D::GetValue(T x, T y, T z, T w, T resolution) kk = skewedCubeOrigin.z & 255; ll = skewedCubeOrigin.w & 255; - gi0 = perm[ii + perm[jj + perm[kk + perm[ll]]]] & 31; - gi1 = perm[ii + off1.x + perm[jj + off1.y + perm[kk + off1.z + perm[ll + off1.w]]]] & 31; - gi2 = perm[ii + off2.x + perm[jj + off2.y + perm[kk + off2.z + perm[ll + off2.w]]]] & 31; - gi3 = perm[ii + off3.x + perm[jj + off3.y + perm[kk + off3.z + perm[ll + off3.w]]]] & 31; - gi4 = perm[ii + 1 + perm[jj + 1 + perm[kk + 1 + perm[ll + 1]]]] % 32; + gi0 = this->perm[ii + this->perm[jj + this->perm[kk + this->perm[ll]]]] & 31; + gi1 = this->perm[ii + off1.x + this->perm[jj + off1.y + this->perm[kk + off1.z + this->perm[ll + off1.w]]]] & 31; + gi2 = this->perm[ii + off2.x + this->perm[jj + off2.y + this->perm[kk + off2.z + this->perm[ll + off2.w]]]] & 31; + gi3 = this->perm[ii + off3.x + this->perm[jj + off3.y + this->perm[kk + off3.z + this->perm[ll + off3.w]]]] & 31; + gi4 = this->perm[ii + 1 + this->perm[jj + 1 + this->perm[kk + 1 + this->perm[ll + 1]]]] % 32; c1 = 0.6 - d1.x*d1.x - d1.y*d1.y - d1.z*d1.z - d1.w*d1.w; c2 = 0.6 - d2.x*d2.x - d2.y*d2.y - d2.z*d2.z - d2.w*d2.w; diff --git a/src/Nazara/Noise/ComplexNoiseBase.cpp b/src/Nazara/Noise/ComplexNoiseBase.cpp deleted file mode 100644 index 0388a7786..000000000 --- a/src/Nazara/Noise/ComplexNoiseBase.cpp +++ /dev/null @@ -1,62 +0,0 @@ -// Copyright (C) 2012 Rémi Bèges -// This file is part of the "Nazara Engine". -// For conditions of distribution and use, see copyright notice in Config.hpp - -#include -#include -#include -#include -#include - -NzComplexNoiseBase::NzComplexNoiseBase() -{ - m_parametersModified = true; - m_lacunarity = 5.0f; - m_hurst = 1.2f; - m_octaves = 3.0f; -} - -void NzComplexNoiseBase::SetLacunarity(float lacunarity) -{ - if(lacunarity != m_lacunarity) - { - m_lacunarity = lacunarity; - m_parametersModified = true; - } -} - -void NzComplexNoiseBase::SetHurstParameter(float h) -{ - if(h != m_hurst) - { - m_hurst = h; - m_parametersModified = true; - } -} - -void NzComplexNoiseBase::SetOctavesNumber(float octaves) -{ - if(octaves != m_octaves && octaves < 30) - { - m_octaves = octaves; - m_parametersModified = true; - } -} - -void NzComplexNoiseBase::RecomputeExponentArray() -{ - if(m_parametersModified) - { - float frequency = 1.0; - m_sum = 0.f; - for (int i(0) ; i < m_octaves; ++i) - { - exponent_array[i] = std::pow( frequency, -m_hurst ); - frequency *= m_lacunarity; - - m_sum += exponent_array[i]; - - } - m_parametersModified = false; - } -} diff --git a/src/Nazara/Noise/NoiseMachine.cpp b/src/Nazara/Noise/NoiseMachine.cpp deleted file mode 100644 index e695d46fe..000000000 --- a/src/Nazara/Noise/NoiseMachine.cpp +++ /dev/null @@ -1,762 +0,0 @@ -// Copyright (C) 2012 Rémi Bèges -// This file is part of the "Nazara Engine". -// For conditions of distribution and use, see copyright notice in Config.hpp - -#include -#include -#include -#include - -NzNoiseMachine::NzNoiseMachine(int seed) -{ - SkewCoeff2D = 0.5*(sqrt(3.0) - 1.0); - UnskewCoeff2D = (3.0-sqrt(3.0))/6; - - SkewCoeff3D = 1/3; - UnskewCoeff3D = 1/6; - - SkewCoeff4D = (sqrt(5) - 1)/4; - UnskewCoeff4D = (5 - sqrt(5))/20; - - - int lookupTemp4D[][4] = - { - {0,1,2,3},{0,1,3,2},{0,0,0,0},{0,2,3,1},{0,0,0,0},{0,0,0,0},{0,0,0,0},{1,2,3,0}, - {0,2,1,3},{0,0,0,0},{0,3,1,2},{0,3,2,1},{0,0,0,0},{0,0,0,0},{0,0,0,0},{1,3,2,0}, - {0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0}, - {1,2,0,3},{0,0,0,0},{1,3,0,2},{0,0,0,0},{0,0,0,0},{0,0,0,0},{2,3,0,1},{2,3,1,0}, - {1,0,2,3},{1,0,3,2},{0,0,0,0},{0,0,0,0},{0,0,0,0},{2,0,3,1},{0,0,0,0},{2,1,3,0}, - {0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0}, - {2,0,1,3},{0,0,0,0},{0,0,0,0},{0,0,0,0},{3,0,1,2},{3,0,2,1},{0,0,0,0},{3,1,2,0}, - {2,1,0,3},{0,0,0,0},{0,0,0,0},{0,0,0,0},{3,1,0,2},{0,0,0,0},{3,2,0,1},{3,2,1,0} - }; - - for(int i(0) ; i < 64 ; ++i) - for(int j(0) ; j < 4 ; ++j) - lookupTable4D[i][j] = lookupTemp4D[i][j]; - - float grad2Temp[][2] = {{1,1},{-1,1},{1,-1},{-1,-1}, - {1,0},{-1,0},{0,1},{0,-1}}; - - for(int i(0) ; i < 8 ; ++i) - for(int j(0) ; j < 2 ; ++j) - gradient2[i][j] = grad2Temp[i][j]; - - int grad3Temp[][3] = { - {1,1,0},{-1,1,0},{1,-1,0},{-1,-1,0}, - {1,0,1},{-1,0,1},{1,0,-1},{-1,0,-1}, - {0,1,1},{0,-1,1},{0,1,-1},{0,-1,-1}, - {1,1,0},{-1,1,0},{0,-1,1},{0,-1,-1} - }; - - for(int i(0) ; i < 16 ; ++i) - for(int j(0) ; j < 3 ; ++j) - gradient3[i][j] = grad3Temp[i][j]; - - int grad4Temp[][4] = - { - {0,1,1,1}, {0,1,1,-1}, {0,1,-1,1}, {0,1,-1,-1}, - {0,-1,1,1},{0,-1,1,-1},{0,-1,-1,1},{0,-1,-1,-1}, - {1,0,1,1}, {1,0,1,-1}, {1,0,-1,1}, {1,0,-1,-1}, - {-1,0,1,1},{-1,0,1,-1},{-1,0,-1,1},{-1,0,-1,-1}, - {1,1,0,1}, {1,1,0,-1}, {1,-1,0,1}, {1,-1,0,-1}, - {-1,1,0,1},{-1,1,0,-1},{-1,-1,0,1},{-1,-1,0,-1}, - {1,1,1,0}, {1,1,-1,0}, {1,-1,1,0}, {1,-1,-1,0}, - {-1,1,1,0},{-1,1,-1,0},{-1,-1,1,0},{-1,-1,-1,0} - }; - - for(int i(0) ; i < 32 ; ++i) - for(int j(0) ; j < 4 ; ++j) - gradient4[i][j] = grad4Temp[i][j]; -} - -//------------------------------ PERLIN ------------------------------ - -float NzNoiseMachine::Get2DPerlinNoiseValue(float x, float y, float res) -{ - x /= res; - y /= res; - - x0 = fastfloor(x); - y0 = fastfloor(y); - - ii = x0 & 255; - jj = y0 & 255; - - gi0 = perm[ii + perm[jj]] & 7; - gi1 = perm[ii + 1 + perm[jj]] & 7; - gi2 = perm[ii + perm[jj + 1]] & 7; - gi3 = perm[ii + 1 + perm[jj + 1]] & 7; - - temp.x = x-x0; - temp.y = y-y0; - - Cx = temp.x * temp.x * temp.x * (temp.x * (temp.x * 6 - 15) + 10); - Cy = temp.y * temp.y * temp.y * (temp.y * (temp.y * 6 - 15) + 10); - - s[0] = gradient2[gi0][0]*temp.x + gradient2[gi0][1]*temp.y; - - temp.x = x-(x0+1); - t[0] = gradient2[gi1][0]*temp.x + gradient2[gi1][1]*temp.y; - - temp.y = y-(y0+1); - v[0] = gradient2[gi3][0]*temp.x + gradient2[gi3][1]*temp.y; - - temp.x = x-x0; - u[0] = gradient2[gi2][0]*temp.x + gradient2[gi2][1]*temp.y; - - Li1 = s[0] + Cx*(t[0]-s[0]); - Li2 = u[0] + Cx*(v[0]-u[0]); - - return Li1 + Cy*(Li2-Li1); -} -float NzNoiseMachine::Get3DPerlinNoiseValue(float x, float y, float z, float res) -{ - x /= res; - y /= res; - z /= res; - - x0 = fastfloor(x); - y0 = fastfloor(y); - z0 = fastfloor(z); - - ii = x0 & 255; - jj = y0 & 255; - kk = z0 & 255; - - gi0 = perm[ii + perm[jj + perm[kk ]]] & 15; - gi1 = perm[ii + 1 + perm[jj + perm[kk ]]] & 15; - gi2 = perm[ii + perm[jj + 1 + perm[kk ]]] & 15; - gi3 = perm[ii + 1 + perm[jj + 1 + perm[kk ]]] & 15; - - gi4 = perm[ii + perm[jj + perm[kk + 1]]] & 15; - gi5 = perm[ii + 1 + perm[jj + perm[kk + 1]]] & 15; - gi6 = perm[ii + perm[jj + 1 + perm[kk + 1]]] & 15; - gi7 = perm[ii + 1 + perm[jj + 1 + perm[kk + 1]]] & 15; - - temp.x = x-x0; - temp.y = y-y0; - temp.z = z-z0; - - Cx = temp.x * temp.x * temp.x * (temp.x * (temp.x * 6 - 15) + 10); - Cy = temp.y * temp.y * temp.y * (temp.y * (temp.y * 6 - 15) + 10); - Cz = temp.z * temp.z * temp.z * (temp.z * (temp.z * 6 - 15) + 10); - - s[0] = gradient3[gi0][0]*temp.x + gradient3[gi0][1]*temp.y + gradient3[gi0][2]*temp.z; - - temp.x = x-(x0+1); - t[0] = gradient3[gi1][0]*temp.x + gradient3[gi1][1]*temp.y + gradient3[gi1][2]*temp.z; - - temp.y = y-(y0+1); - v[0] = gradient3[gi3][0]*temp.x + gradient3[gi3][1]*temp.y + gradient3[gi3][2]*temp.z; - - temp.x = x-x0; - u[0] = gradient3[gi2][0]*temp.x + gradient3[gi2][1]*temp.y + gradient3[gi2][2]*temp.z; - - temp.y = y-y0; - temp.z = z-(z0+1); - s[1] = gradient3[gi4][0]*temp.x + gradient3[gi4][1]*temp.y + gradient3[gi4][2]*temp.z; - - temp.x = x-(x0+1); - t[1] = gradient3[gi5][0]*temp.x + gradient3[gi5][1]*temp.y + gradient3[gi5][2]*temp.z; - - temp.y = y-(y0+1); - v[1] = gradient3[gi7][0]*temp.x + gradient3[gi7][1]*temp.y + gradient3[gi7][2]*temp.z; - - temp.x = x-x0; - u[1] = gradient3[gi6][0]*temp.x + gradient3[gi6][1]*temp.y + gradient3[gi6][2]*temp.z; - - Li1 = s[0] + Cx*(t[0]-s[0]); - Li2 = u[0] + Cx*(v[0]-u[0]); - Li3 = s[1] + Cx*(t[1]-s[1]); - Li4 = u[1] + Cx*(v[1]-u[1]); - - Li5 = Li1 + Cy*(Li2-Li1); - Li6 = Li3 + Cy*(Li4-Li3); - - return Li5 + Cz*(Li6-Li5); -} - -float NzNoiseMachine::Get4DPerlinNoiseValue(float x, float y, float z, float w, float res) -{ - x /= res; - y /= res; - z /= res; - w /= res; - - x0 = fastfloor(x); - y0 = fastfloor(y); - z0 = fastfloor(z); - w0 = fastfloor(w); - - ii = x0 & 255; - jj = y0 & 255; - kk = z0 & 255; - ll = w0 & 255; - - gi0 = perm[ii + perm[jj + perm[kk + perm[ll ]]]] & 31; - gi1 = perm[ii + 1 + perm[jj + perm[kk + perm[ll ]]]] & 31; - gi2 = perm[ii + perm[jj + 1 + perm[kk + perm[ll ]]]] & 31; - gi3 = perm[ii + 1 + perm[jj + 1 + perm[kk + perm[ll ]]]] & 31; - - gi4 = perm[ii + perm[jj + + perm[kk + 1 + perm[ll ]]]] & 31; - gi5 = perm[ii + 1 + perm[jj + + perm[kk + 1 + perm[ll ]]]] & 31; - gi6 = perm[ii + perm[jj + 1 + perm[kk + 1 + perm[ll ]]]] & 31; - gi7 = perm[ii + 1 + perm[jj + 1 + perm[kk + 1 + perm[ll ]]]] & 31; - - gi8 = perm[ii + perm[jj + perm[kk + perm[ll + 1]]]] & 31; - gi9 = perm[ii + 1 + perm[jj + perm[kk + perm[ll + 1]]]] & 31; - gi10 = perm[ii + perm[jj + 1 + perm[kk + perm[ll + 1]]]] & 31; - gi11 = perm[ii + 1 + perm[jj + 1 + perm[kk + perm[ll + 1]]]] & 31; - - gi12 = perm[ii + perm[jj + perm[kk + 1 + perm[ll + 1]]]] & 31; - gi13 = perm[ii + 1 + perm[jj + perm[kk + 1 + perm[ll + 1]]]] & 31; - gi14 = perm[ii + perm[jj + 1 + perm[kk + 1 + perm[ll + 1]]]] & 31; - gi15 = perm[ii + 1 + perm[jj + 1 + perm[kk + 1 + perm[ll + 1]]]] & 31; - - temp.x = x-x0; - temp.y = y-y0; - temp.z = z-z0; - temp.w = w-w0; - - Cx = temp.x * temp.x * temp.x * (temp.x * (temp.x * 6 - 15) + 10); - Cy = temp.y * temp.y * temp.y * (temp.y * (temp.y * 6 - 15) + 10); - Cz = temp.z * temp.z * temp.z * (temp.z * (temp.z * 6 - 15) + 10); - Cw = temp.w * temp.w * temp.w * (temp.w * (temp.w * 6 - 15) + 10); - - s[0] = gradient4[gi0][0]*temp.x + gradient4[gi0][1]*temp.y + gradient4[gi0][2]*temp.z + gradient4[gi0][3]*temp.w; - - temp.x = x-(x0+1); - t[0] = gradient4[gi1][0]*temp.x + gradient4[gi1][1]*temp.y + gradient4[gi1][2]*temp.z + gradient4[gi1][3]*temp.w; - - temp.y = y-(y0+1); - v[0] = gradient4[gi3][0]*temp.x + gradient4[gi3][1]*temp.y + gradient4[gi3][2]*temp.z + gradient4[gi3][3]*temp.w; - - temp.x = x-x0; - u[0] = gradient4[gi2][0]*temp.x + gradient4[gi2][1]*temp.y + gradient4[gi2][2]*temp.z + gradient4[gi2][3]*temp.w; - - temp.y = y-y0; - temp.z = z-(z0+1); - s[1] = gradient4[gi4][0]*temp.x + gradient4[gi4][1]*temp.y + gradient4[gi4][2]*temp.z + gradient4[gi4][3]*temp.w; - - temp.x = x-(x0+1); - t[1] = gradient4[gi5][0]*temp.x + gradient4[gi5][1]*temp.y + gradient4[gi5][2]*temp.z + gradient4[gi5][3]*temp.w; - - temp.y = y-(y0+1); - v[1] = gradient4[gi7][0]*temp.x + gradient4[gi7][1]*temp.y + gradient4[gi7][2]*temp.z + gradient4[gi7][3]*temp.w; - - temp.x = x-x0; - u[1] = gradient4[gi6][0]*temp.x + gradient4[gi6][1]*temp.y + gradient4[gi6][2]*temp.z + gradient4[gi6][3]*temp.w; - - - temp.y = y-y0; - temp.z = z-z0; - temp.w = w-(w0+1); - s[2] = gradient4[gi8][0]*temp.x + gradient4[gi8][1]*temp.y + gradient4[gi8][2]*temp.z + gradient4[gi8][3]*temp.w; - - temp.x = x-(x0+1); - t[2] = gradient4[gi9][0]*temp.x + gradient4[gi9][1]*temp.y + gradient4[gi9][2]*temp.z + gradient4[gi9][3]*temp.w; - - temp.y = y-(y0+1); - v[2] = gradient4[gi11][0]*temp.x + gradient4[gi11][1]*temp.y + gradient4[gi11][2]*temp.z + gradient4[gi11][3]*temp.w; - - temp.x = x-x0; - u[2] = gradient4[gi10][0]*temp.x + gradient4[gi10][1]*temp.y + gradient4[gi10][2]*temp.z + gradient4[gi10][3]*temp.w; - - temp.y = y-y0; - temp.z = z-(z0+1); - s[3] = gradient4[gi12][0]*temp.x + gradient4[gi12][1]*temp.y + gradient4[gi12][2]*temp.z + gradient4[gi12][3]*temp.w; - - temp.x = x-(x0+1); - t[3] = gradient4[gi13][0]*temp.x + gradient4[gi13][1]*temp.y + gradient4[gi13][2]*temp.z + gradient4[gi13][3]*temp.w; - - temp.y = y-(y0+1); - v[3] = gradient4[gi15][0]*temp.x + gradient4[gi15][1]*temp.y + gradient4[gi15][2]*temp.z + gradient4[gi15][3]*temp.w; - - temp.x = x-x0; - u[3] = gradient4[gi14][0]*temp.x + gradient4[gi14][1]*temp.y + gradient4[gi14][2]*temp.z + gradient4[gi14][3]*temp.w; - - Li1 = s[0] + Cx*(t[0]-s[0]); - Li2 = u[0] + Cx*(v[0]-u[0]); - Li3 = s[1] + Cx*(t[1]-s[1]); - Li4 = u[1] + Cx*(v[1]-u[1]); - Li5 = s[2] + Cx*(t[2]-s[2]); - Li6 = u[2] + Cx*(v[2]-u[2]); - Li7 = s[3] + Cx*(t[3]-s[3]); - Li8 = u[3] + Cx*(v[3]-u[3]); - - Li9 = Li1 + Cy*(Li2-Li1); - Li10 = Li3 + Cy*(Li4-Li3); - Li11 = Li5 + Cy*(Li6-Li5); - Li12 = Li7 + Cy*(Li8-Li7); - - Li13 = Li9 + Cz*(Li10-Li9); - Li14 = Li11 + Cz*(Li12-Li11); - - return Li13 + Cw*(Li14-Li13); -} - -//------------------------------ SIMPLEX ------------------------------ - -float NzNoiseMachine::Get2DSimplexNoiseValue(float x, float y, float res) -{ - x /= res; - y /= res; - - sum = (x + y) * SkewCoeff2D; - skewedCubeOrigin.x = fastfloor(x + sum); - skewedCubeOrigin.y = fastfloor(y + sum); - - sum = (skewedCubeOrigin.x + skewedCubeOrigin.y) * UnskewCoeff2D; - unskewedCubeOrigin.x = skewedCubeOrigin.x - sum; - unskewedCubeOrigin.y = skewedCubeOrigin.y - sum; - - unskewedDistToOrigin.x = x - unskewedCubeOrigin.x; - unskewedDistToOrigin.y = y - unskewedCubeOrigin.y; - - if(unskewedDistToOrigin.x > unskewedDistToOrigin.y) - { - off1.x = 1; - off1.y = 0; - } - else - { - off1.x = 0; - off1.y = 1; - } - - d1 = - unskewedDistToOrigin; - - d2.x = d1.x + off1.x - UnskewCoeff2D; - d2.y = d1.y + off1.y - UnskewCoeff2D; - - d3.x = d1.x + 1.0 - 2 * UnskewCoeff2D; - d3.y = d1.y + 1.0 - 2 * UnskewCoeff2D; - - ii = skewedCubeOrigin.x & 255; - jj = skewedCubeOrigin.y & 255; - - gi0 = perm[ii + perm[jj ]] & 7; - gi1 = perm[ii + off1.x + perm[jj + off1.y]] & 7; - gi2 = perm[ii + 1 + perm[jj + 1 ]] & 7; - - c1 = 0.5 - d1.x * d1.x - d1.y * d1.y; - c2 = 0.5 - d2.x * d2.x - d2.y * d2.y; - c3 = 0.5 - d3.x * d3.x - d3.y * d3.y; - - if(c1 < 0) - n1 = 0; - else - n1 = c1*c1*c1*c1*(gradient2[gi0][0] * d1.x + gradient2[gi0][1] * d1.y); - - if(c2 < 0) - n2 = 0; - else - n2 = c2*c2*c2*c2*(gradient2[gi1][0] * d2.x + gradient2[gi1][1] * d2.y); - - if(c3 < 0) - n3 = 0; - else - n3 = c3*c3*c3*c3*(gradient2[gi2][0] * d3.x + gradient2[gi2][1] * d3.y); - - return (n1+n2+n3)*70; -} - -float NzNoiseMachine::Get3DSimplexNoiseValue(float x, float y, float z, float res) -{ - x /= res; - y /= res; - z /= res; - - sum = (x + y + z) * SkewCoeff3D; - skewedCubeOrigin.x = fastfloor(x + sum); - skewedCubeOrigin.y = fastfloor(y + sum); - skewedCubeOrigin.z = fastfloor(z + sum); - - sum = (skewedCubeOrigin.x + skewedCubeOrigin.y + skewedCubeOrigin.z) * UnskewCoeff3D; - unskewedCubeOrigin.x = skewedCubeOrigin.x - sum; - unskewedCubeOrigin.y = skewedCubeOrigin.y - sum; - unskewedCubeOrigin.z = skewedCubeOrigin.z - sum; - - unskewedDistToOrigin.x = x - unskewedCubeOrigin.x; - unskewedDistToOrigin.y = y - unskewedCubeOrigin.y; - unskewedDistToOrigin.z = z - unskewedCubeOrigin.z; - - if(unskewedDistToOrigin.x >= unskewedDistToOrigin.y) - { - if(unskewedDistToOrigin.y >= unskewedDistToOrigin.z) - { - off1.x = 1; - off1.y = 0; - off1.z = 0; - off2.x = 1; - off2.y = 1; - off2.z = 0; - } - else if(unskewedDistToOrigin.x >= unskewedDistToOrigin.z) - { - off1.x = 1; - off1.y = 0; - off1.z = 0; - off2.x = 1; - off2.y = 0; - off2.z = 1; - } - else - { - off1.x = 0; - off1.y = 0; - off1.z = 1; - off2.x = 1; - off2.y = 0; - off2.z = 1; - } - } - else - { - if(unskewedDistToOrigin.y < unskewedDistToOrigin.z) - { - off1.x = 0; - off1.y = 0; - off1.z = 1; - off2.x = 0; - off2.y = 1; - off2.z = 1; - } - else if(unskewedDistToOrigin.x < unskewedDistToOrigin.z) - { - off1.x = 0; - off1.y = 1; - off1.z = 0; - off2.x = 0; - off2.y = 1; - off2.z = 1; - } - else - { - off1.x = 0; - off1.y = 1; - off1.z = 0; - off2.x = 1; - off2.y = 1; - off2.z = 0; - } - } - - d1 = unskewedDistToOrigin; - - d2.x = d1.x - off1.x + UnskewCoeff3D; - d2.y = d1.y - off1.y + UnskewCoeff3D; - d2.z = d1.z - off1.z + UnskewCoeff3D; - - d3.x = d1.x - off2.x + 2*UnskewCoeff3D; - d3.y = d1.y - off2.y + 2*UnskewCoeff3D; - d3.z = d1.z - off2.z + 2*UnskewCoeff3D; - - d4.x = d1.x - 1.0 + 3*UnskewCoeff3D; - d4.y = d1.y - 1.0 + 3*UnskewCoeff3D; - d4.z = d1.z - 1.0 + 3*UnskewCoeff3D; - - ii = skewedCubeOrigin.x & 255; - jj = skewedCubeOrigin.y & 255; - kk = skewedCubeOrigin.z & 255; - - gi0 = perm[ii + perm[jj + perm[kk ]]] % 12; - gi1 = perm[ii + off1.x + perm[jj + off1.y + perm[kk + off1.z]]] % 12; - gi2 = perm[ii + off2.x + perm[jj + off2.y + perm[kk + off2.z]]] % 12; - gi3 = perm[ii + 1 + perm[jj + 1 + perm[kk + 1 ]]] % 12; - - c1 = 0.6 - d1.x * d1.x - d1.y * d1.y - d1.z * d1.z; - c2 = 0.6 - d2.x * d2.x - d2.y * d2.y - d2.z * d2.z; - c3 = 0.6 - d3.x * d3.x - d3.y * d3.y - d3.z * d3.z; - c4 = 0.6 - d4.x * d4.x - d4.y * d4.y - d4.z * d4.z; - - if(c1 < 0) - n1 = 0; - else - n1 = c1*c1*c1*c1*(gradient3[gi0][0] * d1.x + gradient3[gi0][1] * d1.y + gradient3[gi0][2] * d1.z); - - if(c2 < 0) - n2 = 0; - else - n2 = c2*c2*c2*c2*(gradient3[gi1][0] * d2.x + gradient3[gi1][1] * d2.y + gradient3[gi1][2] * d2.z); - - if(c3 < 0) - n3 = 0; - else - n3 = c3*c3*c3*c3*(gradient3[gi2][0] * d3.x + gradient3[gi2][1] * d3.y + gradient3[gi2][2] * d3.z); - - if(c4 < 0) - n4 = 0; - else - n4 = c4*c4*c4*c4*(gradient3[gi3][0] * d4.x + gradient3[gi3][1] * d4.y + gradient3[gi3][2] * d4.z); - - return (n1+n2+n3+n4)*32; -} - -float NzNoiseMachine::Get4DSimplexNoiseValue(float x, float y, float z, float w, float res) -{ - x /= res; - y /= res; - z /= res; - w /= res; - - sum = (x + y + z + w) * SkewCoeff4D; - skewedCubeOrigin.x = fastfloor(x + sum); - skewedCubeOrigin.y = fastfloor(y + sum); - skewedCubeOrigin.z = fastfloor(z + sum); - skewedCubeOrigin.w = fastfloor(w + sum); - - sum = (skewedCubeOrigin.x + skewedCubeOrigin.y + skewedCubeOrigin.z + skewedCubeOrigin.w) * UnskewCoeff4D; - unskewedCubeOrigin.x = skewedCubeOrigin.x - sum; - unskewedCubeOrigin.y = skewedCubeOrigin.y - sum; - unskewedCubeOrigin.z = skewedCubeOrigin.z - sum; - unskewedCubeOrigin.w = skewedCubeOrigin.w - sum; - - unskewedDistToOrigin.x = x - unskewedCubeOrigin.x; - unskewedDistToOrigin.y = y - unskewedCubeOrigin.y; - unskewedDistToOrigin.z = z - unskewedCubeOrigin.z; - unskewedDistToOrigin.w = w - unskewedCubeOrigin.w; - - c1 = (unskewedDistToOrigin.x > unskewedDistToOrigin.y) ? 32 : 0; - c2 = (unskewedDistToOrigin.x > unskewedDistToOrigin.z) ? 16 : 0; - c3 = (unskewedDistToOrigin.y > unskewedDistToOrigin.z) ? 8 : 0; - c4 = (unskewedDistToOrigin.x > unskewedDistToOrigin.w) ? 4 : 0; - c5 = (unskewedDistToOrigin.y > unskewedDistToOrigin.w) ? 2 : 0; - c6 = (unskewedDistToOrigin.z > unskewedDistToOrigin.w) ? 1 : 0; - c = c1 + c2 + c3 + c4 + c5 + c6; - - off1.x = lookupTable4D[c][0] >= 3 ? 1 : 0; - off1.y = lookupTable4D[c][1] >= 3 ? 1 : 0; - off1.z = lookupTable4D[c][2] >= 3 ? 1 : 0; - off1.w = lookupTable4D[c][3] >= 3 ? 1 : 0; - - off2.x = lookupTable4D[c][0] >= 2 ? 1 : 0; - off2.y = lookupTable4D[c][1] >= 2 ? 1 : 0; - off2.z = lookupTable4D[c][2] >= 2 ? 1 : 0; - off2.w = lookupTable4D[c][3] >= 2 ? 1 : 0; - - off3.x = lookupTable4D[c][0] >= 1 ? 1 : 0; - off3.y = lookupTable4D[c][1] >= 1 ? 1 : 0; - off3.z = lookupTable4D[c][2] >= 1 ? 1 : 0; - off3.w = lookupTable4D[c][3] >= 1 ? 1 : 0; - - d1 = unskewedDistToOrigin; - - d2.x = d1.x - off1.x + UnskewCoeff4D; - d2.y = d1.y - off1.y + UnskewCoeff4D; - d2.z = d1.z - off1.z + UnskewCoeff4D; - d2.w = d1.w - off1.w + UnskewCoeff4D; - - d3.x = d1.x - off2.x + 2*UnskewCoeff4D; - d3.y = d1.y - off2.y + 2*UnskewCoeff4D; - d3.z = d1.z - off2.z + 2*UnskewCoeff4D; - d3.w = d1.w - off2.w + 2*UnskewCoeff4D; - - d4.x = d1.x - off3.x + 3*UnskewCoeff4D; - d4.y = d1.y - off3.y + 3*UnskewCoeff4D; - d4.z = d1.z - off3.z + 3*UnskewCoeff4D; - d4.w = d1.w - off3.w + 3*UnskewCoeff4D; - - d5.x = d1.x - 1.0 + 4*UnskewCoeff4D; - d5.y = d1.y - 1.0 + 4*UnskewCoeff4D; - d5.z = d1.z - 1.0 + 4*UnskewCoeff4D; - d5.w = d1.w - 1.0 + 4*UnskewCoeff4D; - - ii = skewedCubeOrigin.x & 255; - jj = skewedCubeOrigin.y & 255; - kk = skewedCubeOrigin.z & 255; - ll = skewedCubeOrigin.w & 255; - - gi0 = perm[ii + perm[jj + perm[kk + perm[ll]]]] & 31; - gi1 = perm[ii + off1.x + perm[jj + off1.y + perm[kk + off1.z + perm[ll + off1.w]]]] & 31; - gi2 = perm[ii + off2.x + perm[jj + off2.y + perm[kk + off2.z + perm[ll + off2.w]]]] & 31; - gi3 = perm[ii + off3.x + perm[jj + off3.y + perm[kk + off3.z + perm[ll + off3.w]]]] & 31; - gi4 = perm[ii + 1 + perm[jj + 1 + perm[kk + 1 + perm[ll + 1]]]] % 32; - - c1 = 0.6 - d1.x*d1.x - d1.y*d1.y - d1.z*d1.z - d1.w*d1.w; - c2 = 0.6 - d2.x*d2.x - d2.y*d2.y - d2.z*d2.z - d2.w*d2.w; - c3 = 0.6 - d3.x*d3.x - d3.y*d3.y - d3.z*d3.z - d3.w*d3.w; - c4 = 0.6 - d4.x*d4.x - d4.y*d4.y - d4.z*d4.z - d4.w*d4.w; - c5 = 0.6 - d5.x*d5.x - d5.y*d5.y - d5.z*d5.z - d5.w*d5.w; - - if(c1 < 0) - n1 = 0; - else - n1 = c1*c1*c1*c1*(gradient4[gi0][0]*d1.x + gradient4[gi0][1]*d1.y + gradient4[gi0][2]*d1.z + gradient4[gi0][3]*d1.w); - - if(c2 < 0) - n2 = 0; - else - n2 = c2*c2*c2*c2*(gradient4[gi1][0]*d2.x + gradient4[gi1][1]*d2.y + gradient4[gi1][2]*d2.z + gradient4[gi1][3]*d2.w); - - if(c3 < 0) - n3 = 0; - else - n3 = c3*c3*c3*c3*(gradient4[gi2][0]*d3.x + gradient4[gi2][1]*d3.y + gradient4[gi2][2]*d3.z + gradient4[gi2][3]*d3.w); - - if(c4 < 0) - n4 = 0; - else - n4 = c4*c4*c4*c4*(gradient4[gi3][0]*d4.x + gradient4[gi3][1]*d4.y + gradient4[gi3][2]*d4.z + gradient4[gi3][3]*d4.w); - - if(c5 < 0) - n5 = 0; - else - n5 = c5*c5*c5*c5*(gradient4[gi4][0]*d5.x + gradient4[gi4][1]*d5.y + gradient4[gi4][2]*d5.z + gradient4[gi4][3]*d5.w); - - return (n1+n2+n3+n4+n5)*27.0; -} - -//------------------------------ CELL ------------------------------ - -float NzNoiseMachine::Get2DCellNoiseValue(float x, float y, float res) -{ - return 0; -} - -float NzNoiseMachine::Get3DCellNoiseValue(float x, float y, float z, float res) -{ - x /= res; - y /= res; - z /= res; - - x0 = static_cast(x); - y0 = static_cast(y); - z0 = static_cast(z); - - return (this->JenkinsHash(x0,y0,z0) & 255); -} -float NzNoiseMachine::Get4DCellNoiseValue(float x, float y, float z, float w, float res) -{ - x /= res; - y /= res; - z /= res; - w /= res; - - x0 = static_cast(x) & 255; - y0 = static_cast(y) & 255; - z0 = static_cast(z) & 255; - w0 = static_cast(w) & 255; - - return 0; -} - -//------------------------------ FBM ------------------------------ - -float NzNoiseMachine::Get2DFBMNoiseValue(float x, float y, float res) -{ - value = 0.0; - RecomputeExponentArray(); - - for (int i(0); i < m_octaves; ++i) - { - value += Get2DPerlinNoiseValue(x,y,res) * exponent_array[i]; - x *= m_lacunarity; - y *= m_lacunarity; - } - remainder = m_octaves - (int)m_octaves; - - if(remainder != 0) - value += remainder * Get2DSimplexNoiseValue(x,y,res) * exponent_array[(int)m_octaves-1]; - - return value * m_sum; -} - -float NzNoiseMachine::Get3DFBMNoiseValue(float x, float y, float z, float res) -{ - value = 0.0; - RecomputeExponentArray(); - - for(int i(0); i < m_octaves; ++i) - { - value += Get3DSimplexNoiseValue(x,y,z,res) * exponent_array[i]; - x *= m_lacunarity; - y *= m_lacunarity; - z *= m_lacunarity; - } - remainder = m_octaves - (int)m_octaves; - - if(remainder != 0) - value += remainder * Get3DSimplexNoiseValue(x,y,z,res) * exponent_array[(int)m_octaves-1]; - - return value * m_sum; -} - -//------------------------------ HYBRID MULTIFRACTAL ------------------------------ - -float NzNoiseMachine::Get2DHybridMultiFractalNoiseValue(float x, float y, float res) -{ - float result, signal, weight, remainder; - float offset = 1; - - RecomputeExponentArray(); - - result = (Get2DSimplexNoiseValue(x,y,res) + offset) * exponent_array[0]; - weight = result; - - x *= m_lacunarity; - y *= m_lacunarity; - - for(int i(1) ; i < m_octaves; ++i) - { - if(weight > 1.0) - weight = 1.0; - - signal = (Get2DSimplexNoiseValue(x,y,res) + offset) * exponent_array[i]; - result += weight * signal; - - weight *= signal; - - x *= m_lacunarity; - y *= m_lacunarity; - - } - - remainder = m_octaves - (int)m_octaves; - - if(remainder != 0) - result += remainder * Get2DSimplexNoiseValue(x,y,res) * exponent_array[(int)m_octaves-1]; - - return result; - -} - -float NzNoiseMachine::Get3DHybridMultiFractalNoiseValue(float x, float y, float z, float res) -{ - float result, signal, weight, remainder; - float offset = 1; - - RecomputeExponentArray(); - - result = (Get3DSimplexNoiseValue(x,y,z,res) + offset) * exponent_array[0]; - weight = result; - - x *= m_lacunarity; - y *= m_lacunarity; - - for(int i(1) ; i < m_octaves; ++i) - { - - if(weight > 1.0) - weight = 1.0; - - signal = ( Get3DSimplexNoiseValue(x,y,z,res) + offset ) * exponent_array[i]; - result += weight * signal; - - weight *= signal; - - x *= m_lacunarity; - y *= m_lacunarity; - - } - - remainder = m_octaves - (int)m_octaves; - - if(remainder != 0) - result += remainder * Get3DSimplexNoiseValue(x,y,z,res) * exponent_array[(int)m_octaves-1]; - - return result; -} - -#include From 745b9dbbd15e2245f81d438c5d72892550cc3f3e Mon Sep 17 00:00:00 2001 From: Remi Beges Date: Tue, 9 Oct 2012 22:15:29 +0200 Subject: [PATCH 10/14] Removed 'virtual' in front of templated function Former-commit-id: 7afa1cdd4ff3db4b73dcb79bcfda6739859c3215 --- include/Nazara/Noise/Abstract2DNoise.hpp | 4 ++-- include/Nazara/Noise/Abstract3DNoise.hpp | 4 ++-- include/Nazara/Noise/Abstract4DNoise.hpp | 4 ++-- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/include/Nazara/Noise/Abstract2DNoise.hpp b/include/Nazara/Noise/Abstract2DNoise.hpp index 9b69a8d3d..ac9e25e1b 100644 --- a/include/Nazara/Noise/Abstract2DNoise.hpp +++ b/include/Nazara/Noise/Abstract2DNoise.hpp @@ -13,8 +13,8 @@ template class NzAbstract2DNoise : public NzMappedNoiseBase { public: - virtual T GetBasicValue(T x, T y); - virtual T GetMappedValue(T x, T y); + T GetBasicValue(T x, T y); + T GetMappedValue(T x, T y); virtual T GetValue(T x, T y, T resolution) = 0; }; diff --git a/include/Nazara/Noise/Abstract3DNoise.hpp b/include/Nazara/Noise/Abstract3DNoise.hpp index c921f9407..5020cc7df 100644 --- a/include/Nazara/Noise/Abstract3DNoise.hpp +++ b/include/Nazara/Noise/Abstract3DNoise.hpp @@ -13,8 +13,8 @@ template class NzAbstract3DNoise : public NzMappedNoiseBase { public: - virtual T GetBasicValue(T x, T y, T z); - virtual T GetMappedValue(T x, T y, T z); + T GetBasicValue(T x, T y, T z); + T GetMappedValue(T x, T y, T z); virtual T GetValue(T x, T y, T z, T resolution) = 0; }; diff --git a/include/Nazara/Noise/Abstract4DNoise.hpp b/include/Nazara/Noise/Abstract4DNoise.hpp index 6f4e24a2c..b3969731d 100644 --- a/include/Nazara/Noise/Abstract4DNoise.hpp +++ b/include/Nazara/Noise/Abstract4DNoise.hpp @@ -13,8 +13,8 @@ template class NzAbstract4DNoise : public NzMappedNoiseBase { public: - virtual T GetBasicValue(T x, T y, T z, T w); - virtual T GetMappedValue(T x, T y, T z, T w); + T GetBasicValue(T x, T y, T z, T w); + T GetMappedValue(T x, T y, T z, T w); virtual T GetValue(T x, T y, T z, T w, T resolution) = 0; }; From 9fef43951b4defeb1feb1c7d7e05c5bf9c00faf3 Mon Sep 17 00:00:00 2001 From: Remi Beges Date: Sat, 27 Oct 2012 18:59:39 +0200 Subject: [PATCH 11/14] Replaced templates by float *Since only valid template parameters were float and double, the whole template aspect has been removed. Double precision would only be used in extremely rare occasions (applications needing high precision and slow performances), it is not relevant to template the whole module for it. Former-commit-id: fc6dd028189c608a6a7b4c312b3e5e3f53a01fd7 --- include/Nazara/Noise/Abstract2DNoise.hpp | 10 ++-- include/Nazara/Noise/Abstract3DNoise.hpp | 10 ++-- include/Nazara/Noise/Abstract4DNoise.hpp | 10 ++-- include/Nazara/Noise/Abstract4DNoise.inl | 23 --------- include/Nazara/Noise/ComplexNoiseBase.hpp | 30 +++++------ include/Nazara/Noise/FBM2D.hpp | 15 ++---- include/Nazara/Noise/MappedNoiseBase.hpp | 22 ++++---- include/Nazara/Noise/Perlin2D.hpp | 21 +++----- include/Nazara/Noise/Perlin3D.hpp | 24 ++++----- include/Nazara/Noise/Perlin4D.hpp | 22 +++----- include/Nazara/Noise/Simplex2D.hpp | 27 ++++------ include/Nazara/Noise/Simplex3D.hpp | 27 ++++------ include/Nazara/Noise/Simplex4D.hpp | 27 ++++------ .../Nazara/Noise/Abstract2DNoise.cpp | 13 ++--- .../Nazara/Noise/Abstract3DNoise.cpp | 13 ++--- src/Nazara/Noise/Abstract4DNoise.cpp | 20 ++++++++ .../Nazara/Noise/ComplexNoiseBase.cpp | 38 +++++--------- .../FBM2D.inl => src/Nazara/Noise/FBM2D.cpp | 28 ++++------ .../Nazara/Noise/MappedNoiseBase.cpp | 27 ++++------ .../Nazara/Noise/Perlin2D.cpp | 23 ++++----- .../Nazara/Noise/Perlin3D.cpp | 33 ++++++------ .../Nazara/Noise/Perlin4D.cpp | 51 +++++++++---------- .../Nazara/Noise/Simplex2D.cpp | 21 ++++---- .../Nazara/Noise/Simplex3D.cpp | 23 ++++----- .../Nazara/Noise/Simplex4D.cpp | 27 +++++----- 25 files changed, 239 insertions(+), 346 deletions(-) delete mode 100644 include/Nazara/Noise/Abstract4DNoise.inl rename include/Nazara/Noise/Abstract2DNoise.inl => src/Nazara/Noise/Abstract2DNoise.cpp (52%) rename include/Nazara/Noise/Abstract3DNoise.inl => src/Nazara/Noise/Abstract3DNoise.cpp (50%) create mode 100644 src/Nazara/Noise/Abstract4DNoise.cpp rename include/Nazara/Noise/ComplexNoiseBase.inl => src/Nazara/Noise/ComplexNoiseBase.cpp (62%) rename include/Nazara/Noise/FBM2D.inl => src/Nazara/Noise/FBM2D.cpp (69%) rename include/Nazara/Noise/MappedNoiseBase.inl => src/Nazara/Noise/MappedNoiseBase.cpp (52%) rename include/Nazara/Noise/Perlin2D.inl => src/Nazara/Noise/Perlin2D.cpp (69%) rename include/Nazara/Noise/Perlin3D.inl => src/Nazara/Noise/Perlin3D.cpp (70%) rename include/Nazara/Noise/Perlin4D.inl => src/Nazara/Noise/Perlin4D.cpp (69%) rename include/Nazara/Noise/Simplex2D.inl => src/Nazara/Noise/Simplex2D.cpp (78%) rename include/Nazara/Noise/Simplex3D.inl => src/Nazara/Noise/Simplex3D.cpp (84%) rename include/Nazara/Noise/Simplex4D.inl => src/Nazara/Noise/Simplex4D.cpp (85%) diff --git a/include/Nazara/Noise/Abstract2DNoise.hpp b/include/Nazara/Noise/Abstract2DNoise.hpp index ac9e25e1b..37f035d07 100644 --- a/include/Nazara/Noise/Abstract2DNoise.hpp +++ b/include/Nazara/Noise/Abstract2DNoise.hpp @@ -10,14 +10,12 @@ #include #include -template class NzAbstract2DNoise : public NzMappedNoiseBase +class NAZARA_API NzAbstract2DNoise : public NzMappedNoiseBase { public: - T GetBasicValue(T x, T y); - T GetMappedValue(T x, T y); - virtual T GetValue(T x, T y, T resolution) = 0; + float GetBasicValue(float x, float y); + float GetMappedValue(float x, float y); + virtual float GetValue(float x, float y, float resolution) = 0; }; -#include - #endif // NAZARA_ABSTRACT2DNOISE_HPP diff --git a/include/Nazara/Noise/Abstract3DNoise.hpp b/include/Nazara/Noise/Abstract3DNoise.hpp index 5020cc7df..af1866b97 100644 --- a/include/Nazara/Noise/Abstract3DNoise.hpp +++ b/include/Nazara/Noise/Abstract3DNoise.hpp @@ -10,14 +10,12 @@ #include #include -template class NzAbstract3DNoise : public NzMappedNoiseBase +class NAZARA_API NzAbstract3DNoise : public NzMappedNoiseBase { public: - T GetBasicValue(T x, T y, T z); - T GetMappedValue(T x, T y, T z); - virtual T GetValue(T x, T y, T z, T resolution) = 0; + float GetBasicValue(float x, float y, float z); + float GetMappedValue(float x, float y, float z); + virtual float GetValue(float x, float y, float z, float resolution) = 0; }; -#include - #endif // NAZARA_ABSTRACT3DNOISE_HPP diff --git a/include/Nazara/Noise/Abstract4DNoise.hpp b/include/Nazara/Noise/Abstract4DNoise.hpp index b3969731d..e17f5cb0b 100644 --- a/include/Nazara/Noise/Abstract4DNoise.hpp +++ b/include/Nazara/Noise/Abstract4DNoise.hpp @@ -10,14 +10,12 @@ #include #include -template class NzAbstract4DNoise : public NzMappedNoiseBase +class NAZARA_API NzAbstract4DNoise : public NzMappedNoiseBase { public: - T GetBasicValue(T x, T y, T z, T w); - T GetMappedValue(T x, T y, T z, T w); - virtual T GetValue(T x, T y, T z, T w, T resolution) = 0; + float GetBasicValue(float x, float y, float z, float w); + float GetMappedValue(float x, float y, float z, float w); + virtual float GetValue(float x, float y, float z, float w, float resolution) = 0; }; -#include - #endif // NAZARA_ABSTRACT4DNOISE_HPP diff --git a/include/Nazara/Noise/Abstract4DNoise.inl b/include/Nazara/Noise/Abstract4DNoise.inl deleted file mode 100644 index 579938446..000000000 --- a/include/Nazara/Noise/Abstract4DNoise.inl +++ /dev/null @@ -1,23 +0,0 @@ -// Copyright (C) 2012 Rémi Bèges -// This file is part of the "Nazara Engine". -// For conditions of distribution and use, see copyright notice in Config.hpp - -#include -#include -#include -#include -#include - -template -T NzAbstract4DNoise::GetBasicValue(T x, T y, T z, T w) -{ - return this->GetValue(x,y,z,w,this->m_resolution); -} - -template -T NzAbstract4DNoise::GetMappedValue(T x, T y, T z, T w) -{ - return (this->GetValue(x,y,z,w,this->m_resolution) + this->m_offset) * this->m_gain ; -} - -#include diff --git a/include/Nazara/Noise/ComplexNoiseBase.hpp b/include/Nazara/Noise/ComplexNoiseBase.hpp index 9f969c1be..95ff6a6e7 100644 --- a/include/Nazara/Noise/ComplexNoiseBase.hpp +++ b/include/Nazara/Noise/ComplexNoiseBase.hpp @@ -8,33 +8,31 @@ #define COMPLEXNOISEBASE_HPP #include +#include -template -class NzComplexNoiseBase +class NAZARA_API NzComplexNoiseBase { public: NzComplexNoiseBase(); ~NzComplexNoiseBase() = default; - T GetOctaveNumber() const; - T GetLacunarity() const; - T GetHurstParameter() const; - void SetLacunarity(T lacunarity); - void SetHurstParameter(T h); - void SetOctavesNumber(T octaves); + const std::array& GetExponentArray() const; //For debug purpose + float GetHurstParameter() const; + float GetLacunarity() const; + float GetOctaveNumber() const; + void SetHurstParameter(float h); + void SetLacunarity(float lacunarity); + void SetOctavesNumber(float octaves); void RecomputeExponentArray(); protected: - T m_lacunarity; - T m_hurst; - T m_octaves; - T exponent_array[30]; - T m_sum; + float m_lacunarity; + float m_hurst; + float m_octaves; + std::array exponent_array; + float m_sum; private: bool m_parametersModified; - }; -#include - #endif // COMPLEXNOISEBASE_HPP diff --git a/include/Nazara/Noise/FBM2D.hpp b/include/Nazara/Noise/FBM2D.hpp index 0223f23f8..0f2b12e79 100644 --- a/include/Nazara/Noise/FBM2D.hpp +++ b/include/Nazara/Noise/FBM2D.hpp @@ -11,23 +11,18 @@ #include #include -template class NzFBM2D : public NzAbstract2DNoise, public NzComplexNoiseBase +class NAZARA_API NzFBM2D : public NzAbstract2DNoise, public NzComplexNoiseBase { public: NzFBM2D(nzNoises source, int seed); - T GetValue(T x, T y, T resolution); + float GetValue(float x, float y, float resolution); ~NzFBM2D(); protected: private: - NzAbstract2DNoise* m_source; - T m_value; - T m_remainder; + NzAbstract2DNoise* m_source; + float m_value; + float m_remainder; nzNoises m_noiseType; }; -typedef NzFBM2D NzFBM2Df; -typedef NzFBM2D NzFBM2Dd; - -#include - #endif // FBM2DNOISE_HPP diff --git a/include/Nazara/Noise/MappedNoiseBase.hpp b/include/Nazara/Noise/MappedNoiseBase.hpp index 5650d1cd4..b17fe4b2e 100644 --- a/include/Nazara/Noise/MappedNoiseBase.hpp +++ b/include/Nazara/Noise/MappedNoiseBase.hpp @@ -10,24 +10,22 @@ #include #include -template class NzMappedNoiseBase : public NzNoiseBase +class NAZARA_API NzMappedNoiseBase : public NzNoiseBase { public: NzMappedNoiseBase(); ~NzMappedNoiseBase() = default; - T GetGain() const; - T GetOffset() const; - T GetResolution() const; - void SetGain(T gain); - void SetOffset(T offset); - void SetResolution(T resolution); + float GetGain() const; + float GetOffset() const; + float GetResolution() const; + void SetGain(float gain); + void SetOffset(float offset); + void SetResolution(float resolution); protected: - T m_gain; - T m_offset; - T m_resolution; + float m_gain; + float m_offset; + float m_resolution; }; -#include - #endif // NAZARA_MAPPEDNOISEBASE_HPP diff --git a/include/Nazara/Noise/Perlin2D.hpp b/include/Nazara/Noise/Perlin2D.hpp index d15f7ebd7..a437020ec 100644 --- a/include/Nazara/Noise/Perlin2D.hpp +++ b/include/Nazara/Noise/Perlin2D.hpp @@ -12,28 +12,23 @@ #include #include -template class NzPerlin2D : public NzAbstract2DNoise +class NAZARA_API NzPerlin2D : public NzAbstract2DNoise { public: NzPerlin2D(); - T GetValue(T x, T y, T resolution); - virtual ~NzPerlin2D() = default; + float GetValue(float x, float y, float resolution); + ~NzPerlin2D() = default; protected: private: int x0, y0; int gi0,gi1,gi2,gi3; int ii, jj; - T gradient2[8][2]; - T s,t,u,v; - T Cx,Cy; - T Li1, Li2; - NzVector2 temp; + float gradient2[8][2]; + float s,t,u,v; + float Cx,Cy; + float Li1, Li2; + NzVector2 temp; }; -typedef NzPerlin2D NzPerlin2Df; -typedef NzPerlin2D NzPerlin2Dd; - -#include - #endif // PERLIN2D_HPP diff --git a/include/Nazara/Noise/Perlin3D.hpp b/include/Nazara/Noise/Perlin3D.hpp index d414ba6be..ada704e9d 100644 --- a/include/Nazara/Noise/Perlin3D.hpp +++ b/include/Nazara/Noise/Perlin3D.hpp @@ -12,30 +12,24 @@ #include #include -template class NzPerlin3D : public NzAbstract3DNoise +class NAZARA_API NzPerlin3D : public NzAbstract3DNoise { public: NzPerlin3D(); - T GetValue(T x, T y, T z, T resolution); + float GetValue(float x, float y, float z, float resolution); ~NzPerlin3D() = default; protected: private: int x0,y0,z0; int gi0,gi1,gi2,gi3,gi4,gi5,gi6,gi7; int ii,jj,kk; - int gradient3[16][3]; - T Li1,Li2,Li3,Li4,Li5,Li6; - T s[2],t[2],u[2],v[2]; - T Cx,Cy,Cz; - T nx,ny,nz; - T tmp; - NzVector3 temp; - + float gradient3[16][3]; + float Li1,Li2,Li3,Li4,Li5,Li6; + float s[2],t[2],u[2],v[2]; + float Cx,Cy,Cz; + float nx,ny,nz; + float tmp; + NzVector3 temp; }; -typedef NzPerlin3D NzPerlin3Df; -typedef NzPerlin3D NzPerlin3Dd; - -#include - #endif // PERLIN3D_HPP diff --git a/include/Nazara/Noise/Perlin4D.hpp b/include/Nazara/Noise/Perlin4D.hpp index 52be1093e..8a04894b4 100644 --- a/include/Nazara/Noise/Perlin4D.hpp +++ b/include/Nazara/Noise/Perlin4D.hpp @@ -12,29 +12,23 @@ #include #include -template class NzPerlin4D : public NzAbstract4DNoise +class NAZARA_API NzPerlin4D : public NzAbstract4DNoise { public: NzPerlin4D(); - T GetValue(T x, T y, T z, T w, T resolution); + float GetValue(float x, float y, float z, float w, float resolution); ~NzPerlin4D() = default; protected: private: int x0,y0,z0,w0; int gi0,gi1,gi2,gi3,gi4,gi5,gi6,gi7,gi8,gi9,gi10,gi11,gi12,gi13,gi14,gi15; int ii,jj,kk,ll; - int gradient4[32][4]; - T Li1,Li2,Li3,Li4,Li5,Li6,Li7,Li8,Li9,Li10,Li11,Li12,Li13,Li14; - T s[4],t[4],u[4],v[4]; - T Cx,Cy,Cz,Cw; - T tmp; - NzVector4 temp; - + float gradient4[32][4]; + float Li1,Li2,Li3,Li4,Li5,Li6,Li7,Li8,Li9,Li10,Li11,Li12,Li13,Li14; + float s[4],t[4],u[4],v[4]; + float Cx,Cy,Cz,Cw; + float tmp; + NzVector4 temp; }; -typedef NzPerlin4D NzPerlin4Df; -typedef NzPerlin4D NzPerlin4Dd; - -#include - #endif // PERLIN4D_HPP diff --git a/include/Nazara/Noise/Simplex2D.hpp b/include/Nazara/Noise/Simplex2D.hpp index 3de0b1572..c121d0d55 100644 --- a/include/Nazara/Noise/Simplex2D.hpp +++ b/include/Nazara/Noise/Simplex2D.hpp @@ -12,33 +12,26 @@ #include #include -template class NzSimplex2D : public NzAbstract2DNoise +class NAZARA_API NzSimplex2D : public NzAbstract2DNoise { public: NzSimplex2D(); - T GetValue(T x, T y, T resolution); + float GetValue(float x, float y, float resolution); virtual ~NzSimplex2D() = default; protected: private: int ii,jj; int gi0,gi1,gi2; NzVector2i skewedCubeOrigin,off1; - T n1,n2,n3; - T c1,c2,c3; - T gradient2[8][2]; - T UnskewCoeff2D; - T SkewCoeff2D; - T sum; - NzVector2 unskewedCubeOrigin, unskewedDistToOrigin; - NzVector2 d1,d2,d3; - - + float n1,n2,n3; + float c1,c2,c3; + float gradient2[8][2]; + float UnskewCoeff2D; + float SkewCoeff2D; + float sum; + NzVector2 unskewedCubeOrigin, unskewedDistToOrigin; + NzVector2 d1,d2,d3; }; -typedef NzSimplex2D NzSimplex2Df; -typedef NzSimplex2D NzSimplex2Dd; - -#include - #endif // SIMPLEX2D_HPP diff --git a/include/Nazara/Noise/Simplex3D.hpp b/include/Nazara/Noise/Simplex3D.hpp index c90b46678..a6d636875 100644 --- a/include/Nazara/Noise/Simplex3D.hpp +++ b/include/Nazara/Noise/Simplex3D.hpp @@ -12,33 +12,26 @@ #include #include -template class NzSimplex3D : public NzAbstract3DNoise +class NAZARA_API NzSimplex3D : public NzAbstract3DNoise { public: NzSimplex3D(); - T GetValue(T x, T y, T z, T resolution); + float GetValue(float x, float y, float z, float resolution); ~NzSimplex3D() = default; protected: private: int ii,jj,kk; int gi0,gi1,gi2,gi3; NzVector3i skewedCubeOrigin,off1,off2; - T n1,n2,n3,n4; - T c1,c2,c3,c4; - T gradient3[12][3]; - T UnskewCoeff3D; - T SkewCoeff3D; - T sum; - NzVector3 unskewedCubeOrigin, unskewedDistToOrigin; - NzVector3 d1,d2,d3,d4; - - + float n1,n2,n3,n4; + float c1,c2,c3,c4; + float gradient3[12][3]; + float UnskewCoeff3D; + float SkewCoeff3D; + float sum; + NzVector3 unskewedCubeOrigin, unskewedDistToOrigin; + NzVector3 d1,d2,d3,d4; }; -typedef NzSimplex3D NzSimplex3Df; -typedef NzSimplex3D NzSimplex3Dd; - -#include - #endif // SIMPLEX3D_HPP diff --git a/include/Nazara/Noise/Simplex4D.hpp b/include/Nazara/Noise/Simplex4D.hpp index 7aea7dbb7..cf159de79 100644 --- a/include/Nazara/Noise/Simplex4D.hpp +++ b/include/Nazara/Noise/Simplex4D.hpp @@ -12,35 +12,28 @@ #include #include -template class NzSimplex4D : public NzAbstract4DNoise +class NAZARA_API NzSimplex4D : public NzAbstract4DNoise { public: NzSimplex4D(); - T GetValue(T x, T y, T z, T w, T resolution); + float GetValue(float x, float y, float z, float w, float resolution); ~NzSimplex4D() = default; protected: private: int ii,jj,kk,ll; int gi0,gi1,gi2,gi3,gi4; NzVector4i skewedCubeOrigin,off1,off2,off3; - T n1,n2,n3,n4,n5; - T c1,c2,c3,c4,c5,c6; - T gradient4[32][4]; int lookupTable4D[64][4]; int c; - T UnskewCoeff4D; - T SkewCoeff4D; - T sum; - NzVector4 unskewedCubeOrigin, unskewedDistToOrigin; - NzVector4 d1,d2,d3,d4,d5; - - + float n1,n2,n3,n4,n5; + float c1,c2,c3,c4,c5,c6; + float gradient4[32][4]; + float UnskewCoeff4D; + float SkewCoeff4D; + float sum; + NzVector4 unskewedCubeOrigin, unskewedDistToOrigin; + NzVector4 d1,d2,d3,d4,d5; }; -typedef NzSimplex4D NzSimplex4Df; -typedef NzSimplex4D NzSimplex4Dd; - -#include - #endif // SIMPLEX4D_H diff --git a/include/Nazara/Noise/Abstract2DNoise.inl b/src/Nazara/Noise/Abstract2DNoise.cpp similarity index 52% rename from include/Nazara/Noise/Abstract2DNoise.inl rename to src/Nazara/Noise/Abstract2DNoise.cpp index 98b738d36..601e94cbe 100644 --- a/include/Nazara/Noise/Abstract2DNoise.inl +++ b/src/Nazara/Noise/Abstract2DNoise.cpp @@ -7,17 +7,14 @@ #include #include #include +#include -template -T NzAbstract2DNoise::GetBasicValue(T x, T y) +float NzAbstract2DNoise::GetBasicValue(float x, float y) { - return this->GetValue(x,y,this->m_resolution); + return this->GetValue(x,y,m_resolution); } -template -T NzAbstract2DNoise::GetMappedValue(T x, T y) +float NzAbstract2DNoise::GetMappedValue(float x, float y) { - return (this->GetValue(x,y,this->m_resolution) + this->m_offset) * this->m_gain; + return (this->GetValue(x,y,m_resolution) + m_offset) * m_gain; } - -#include diff --git a/include/Nazara/Noise/Abstract3DNoise.inl b/src/Nazara/Noise/Abstract3DNoise.cpp similarity index 50% rename from include/Nazara/Noise/Abstract3DNoise.inl rename to src/Nazara/Noise/Abstract3DNoise.cpp index cc32aa556..b4914a708 100644 --- a/include/Nazara/Noise/Abstract3DNoise.inl +++ b/src/Nazara/Noise/Abstract3DNoise.cpp @@ -7,17 +7,14 @@ #include #include #include +#include -template -T NzAbstract3DNoise::GetBasicValue(T x, T y, T z) +float NzAbstract3DNoise::GetBasicValue(float x, float y, float z) { - return this->GetValue(x,y,z,this->m_resolution); + return this->GetValue(x,y,z,m_resolution); } -template -T NzAbstract3DNoise::GetMappedValue(T x, T y, T z) +float NzAbstract3DNoise::GetMappedValue(float x, float y, float z) { - return (this->GetValue(x,y,z,this->m_resolution) + this->m_offset) * this->m_gain ; + return (this->GetValue(x,y,z,m_resolution) + m_offset) * m_gain ; } - -#include diff --git a/src/Nazara/Noise/Abstract4DNoise.cpp b/src/Nazara/Noise/Abstract4DNoise.cpp new file mode 100644 index 000000000..9abf666c2 --- /dev/null +++ b/src/Nazara/Noise/Abstract4DNoise.cpp @@ -0,0 +1,20 @@ +// Copyright (C) 2012 Rémi Bèges +// This file is part of the "Nazara Engine". +// For conditions of distribution and use, see copyright notice in Config.hpp + +#include +#include +#include +#include +#include +#include + +float NzAbstract4DNoise::GetBasicValue(float x, float y, float z, float w) +{ + return this->GetValue(x,y,z,w,m_resolution); +} + +float NzAbstract4DNoise::GetMappedValue(float x, float y, float z, float w) +{ + return (this->GetValue(x,y,z,w,m_resolution) + m_offset) * m_gain ; +} diff --git a/include/Nazara/Noise/ComplexNoiseBase.inl b/src/Nazara/Noise/ComplexNoiseBase.cpp similarity index 62% rename from include/Nazara/Noise/ComplexNoiseBase.inl rename to src/Nazara/Noise/ComplexNoiseBase.cpp index 29c77e431..b3284f480 100644 --- a/include/Nazara/Noise/ComplexNoiseBase.inl +++ b/src/Nazara/Noise/ComplexNoiseBase.cpp @@ -6,12 +6,9 @@ #include #include #include +#include -#include -using namespace std; - -template -NzComplexNoiseBase::NzComplexNoiseBase() +NzComplexNoiseBase::NzComplexNoiseBase() { m_parametersModified = true; m_lacunarity = 5.0f; @@ -24,27 +21,28 @@ NzComplexNoiseBase::NzComplexNoiseBase() } } -template -T NzComplexNoiseBase::GetLacunarity() const +const std::array& NzComplexNoiseBase::GetExponentArray() const +{ + return exponent_array; +} + +float NzComplexNoiseBase::GetLacunarity() const { return m_lacunarity; } -template -T NzComplexNoiseBase::GetHurstParameter() const +float NzComplexNoiseBase::GetHurstParameter() const { return m_hurst; } -template -T NzComplexNoiseBase::GetOctaveNumber() const +float NzComplexNoiseBase::GetOctaveNumber() const { return m_octaves; } -template -void NzComplexNoiseBase::SetLacunarity(T lacunarity) +void NzComplexNoiseBase::SetLacunarity(float lacunarity) { // if(lacunarity != m_lacunarity) //{ @@ -53,8 +51,7 @@ void NzComplexNoiseBase::SetLacunarity(T lacunarity) //} } -template -void NzComplexNoiseBase::SetHurstParameter(T h) +void NzComplexNoiseBase::SetHurstParameter(float h) { //if(h != m_hurst) //{ @@ -63,8 +60,7 @@ void NzComplexNoiseBase::SetHurstParameter(T h) //} } -template -void NzComplexNoiseBase::SetOctavesNumber(T octaves) +void NzComplexNoiseBase::SetOctavesNumber(float octaves) { if(octaves <= 30.0f) m_octaves = octaves; @@ -75,28 +71,22 @@ void NzComplexNoiseBase::SetOctavesNumber(T octaves) } -template -void NzComplexNoiseBase::RecomputeExponentArray() +void NzComplexNoiseBase::RecomputeExponentArray() { if(m_parametersModified) { - cout<<"Recomputing exponent array"<(m_octaves) ; ++i) { exponent_array[i] = std::pow( frequency, -m_hurst ); - cout<<"expo["<m_sum<m_octaves - static_cast(this->m_octaves); - //if(!NzNumberEquals(remainder, static_cast(0.0))) + //if(!NzNumberEquals(remainder, static_cast(0.0))) // m_value += remainder * Get2DSimplexNoiseValue(x,y,resolution) * exponent_array[(int)m_octaves-1]; //0.65 is an experimental value to make the noise stick closer to [-1 , 1] return m_value / (this->m_sum * 0.65); } -template -NzFBM2D::~NzFBM2D() +NzFBM2D::~NzFBM2D() { switch(m_noiseType) { case PERLIN: - delete dynamic_cast*>(m_source); + delete dynamic_cast(m_source); break; default: - delete dynamic_cast*>(m_source); + delete dynamic_cast(m_source); break; } } - -#include diff --git a/include/Nazara/Noise/MappedNoiseBase.inl b/src/Nazara/Noise/MappedNoiseBase.cpp similarity index 52% rename from include/Nazara/Noise/MappedNoiseBase.inl rename to src/Nazara/Noise/MappedNoiseBase.cpp index 9f70dee87..d7464eb9e 100644 --- a/include/Nazara/Noise/MappedNoiseBase.inl +++ b/src/Nazara/Noise/MappedNoiseBase.cpp @@ -8,48 +8,41 @@ #include #include #include +#include - -template -NzMappedNoiseBase::NzMappedNoiseBase() : m_gain(1), m_offset(0), m_resolution(30) +NzMappedNoiseBase::NzMappedNoiseBase() : m_gain(1.f), m_offset(0.f), m_resolution(30.f) { } -template -T NzMappedNoiseBase::GetGain() const +float NzMappedNoiseBase::GetGain() const { return m_gain; } -template -T NzMappedNoiseBase::GetOffset() const +float NzMappedNoiseBase::GetOffset() const { return m_offset; } -template -T NzMappedNoiseBase::GetResolution() const +float NzMappedNoiseBase::GetResolution() const { return m_resolution; } -template -void NzMappedNoiseBase::SetGain(T gain) +void NzMappedNoiseBase::SetGain(float gain) { m_gain = gain; } -template -void NzMappedNoiseBase::SetOffset(T offset) +void NzMappedNoiseBase::SetOffset(float offset) { m_offset = offset; } -template -void NzMappedNoiseBase::SetResolution(T resolution) +void NzMappedNoiseBase::SetResolution(float resolution) { - if (NzNumberEquals(resolution, static_cast(0.0))) + if (NzNumberEquals(resolution, 0.f)) { NzStringStream ss; ss << __FILE__ << ':' << __LINE__ << " : resolution cannot be 0.0f"; @@ -58,5 +51,3 @@ void NzMappedNoiseBase::SetResolution(T resolution) } m_resolution = resolution; } - -#include diff --git a/include/Nazara/Noise/Perlin2D.inl b/src/Nazara/Noise/Perlin2D.cpp similarity index 69% rename from include/Nazara/Noise/Perlin2D.inl rename to src/Nazara/Noise/Perlin2D.cpp index 169cb6bf8..157dab5d4 100644 --- a/include/Nazara/Noise/Perlin2D.inl +++ b/src/Nazara/Noise/Perlin2D.cpp @@ -4,12 +4,12 @@ #include #include +#include #include -template -NzPerlin2D::NzPerlin2D() +NzPerlin2D::NzPerlin2D() { - T grad2Temp[][2] = {{1,1},{-1,1},{1,-1},{-1,-1}, + int grad2Temp[][2] = {{1,1},{-1,1},{1,-1},{-1,-1}, {1,0},{-1,0},{0,1},{0,-1}}; for(int i(0) ; i < 8 ; ++i) @@ -17,22 +17,21 @@ NzPerlin2D::NzPerlin2D() gradient2[i][j] = grad2Temp[i][j]; } -template -T NzPerlin2D::GetValue(T x, T y, T resolution) +float NzPerlin2D::GetValue(float x, float y, float resolution) { x *= resolution; y *= resolution; - x0 = this->fastfloor(x); - y0 = this->fastfloor(y); + x0 = fastfloor(x); + y0 = fastfloor(y); ii = x0 & 255; jj = y0 & 255; - gi0 = this->perm[ii + this->perm[jj]] & 7; - gi1 = this->perm[ii + 1 + this->perm[jj]] & 7; - gi2 = this->perm[ii + this->perm[jj + 1]] & 7; - gi3 = this->perm[ii + 1 + this->perm[jj + 1]] & 7; + gi0 = perm[ii + perm[jj]] & 7; + gi1 = perm[ii + 1 + perm[jj]] & 7; + gi2 = perm[ii + perm[jj + 1]] & 7; + gi3 = perm[ii + 1 + perm[jj + 1]] & 7; temp.x = x-x0; temp.y = y-y0; @@ -56,5 +55,3 @@ T NzPerlin2D::GetValue(T x, T y, T resolution) return Li1 + Cy*(Li2-Li1); } - -#include diff --git a/include/Nazara/Noise/Perlin3D.inl b/src/Nazara/Noise/Perlin3D.cpp similarity index 70% rename from include/Nazara/Noise/Perlin3D.inl rename to src/Nazara/Noise/Perlin3D.cpp index 61e2a14c8..774ee7436 100644 --- a/include/Nazara/Noise/Perlin3D.inl +++ b/src/Nazara/Noise/Perlin3D.cpp @@ -4,12 +4,12 @@ #include #include +#include #include -template -NzPerlin3D::NzPerlin3D() +NzPerlin3D::NzPerlin3D() { - int grad3Temp[][3] = { + float grad3Temp[][3] = { {1,1,0},{-1,1,0},{1,-1,0},{-1,-1,0}, {1,0,1},{-1,0,1},{1,0,-1},{-1,0,-1}, {0,1,1},{0,-1,1},{0,1,-1},{0,-1,-1}, @@ -21,30 +21,29 @@ NzPerlin3D::NzPerlin3D() gradient3[i][j] = grad3Temp[i][j]; } -template -T NzPerlin3D::GetValue(T x, T y, T z, T resolution) +float NzPerlin3D::GetValue(float x, float y, float z, float resolution) { x /= resolution; y /= resolution; z /= resolution; - x0 = this->fastfloor(x); - y0 = this->fastfloor(y); - z0 = this->fastfloor(z); + x0 = fastfloor(x); + y0 = fastfloor(y); + z0 = fastfloor(z); ii = x0 & 255; jj = y0 & 255; kk = z0 & 255; - gi0 = this->perm[ii + this->perm[jj + this->perm[kk]]] & 15; - gi1 = this->perm[ii + 1 + this->perm[jj + this->perm[kk]]] & 15; - gi2 = this->perm[ii + this->perm[jj + 1 + this->perm[kk]]] & 15; - gi3 = this->perm[ii + 1 + this->perm[jj + 1 + this->perm[kk]]] & 15; + gi0 = perm[ii + perm[jj + perm[kk]]] & 15; + gi1 = perm[ii + 1 + perm[jj + perm[kk]]] & 15; + gi2 = perm[ii + perm[jj + 1 + perm[kk]]] & 15; + gi3 = perm[ii + 1 + perm[jj + 1 + perm[kk]]] & 15; - gi4 = this->perm[ii + this->perm[jj + this->perm[kk + 1]]] & 15; - gi5 = this->perm[ii + 1 + this->perm[jj + this->perm[kk + 1]]] & 15; - gi6 = this->perm[ii + this->perm[jj + 1 + this->perm[kk + 1]]] & 15; - gi7 = this->perm[ii + 1 + this->perm[jj + 1 + this->perm[kk + 1]]] & 15; + gi4 = perm[ii + perm[jj + perm[kk + 1]]] & 15; + gi5 = perm[ii + 1 + perm[jj + perm[kk + 1]]] & 15; + gi6 = perm[ii + perm[jj + 1 + perm[kk + 1]]] & 15; + gi7 = perm[ii + 1 + perm[jj + 1 + perm[kk + 1]]] & 15; temp.x = x-x0; temp.y = y-y0; @@ -88,5 +87,3 @@ T NzPerlin3D::GetValue(T x, T y, T z, T resolution) return Li5 + Cz*(Li6-Li5); } - -#include diff --git a/include/Nazara/Noise/Perlin4D.inl b/src/Nazara/Noise/Perlin4D.cpp similarity index 69% rename from include/Nazara/Noise/Perlin4D.inl rename to src/Nazara/Noise/Perlin4D.cpp index 44d010b27..308a4d3fc 100644 --- a/include/Nazara/Noise/Perlin4D.inl +++ b/src/Nazara/Noise/Perlin4D.cpp @@ -4,12 +4,12 @@ #include #include +#include #include -template -NzPerlin4D::NzPerlin4D() +NzPerlin4D::NzPerlin4D() { - int grad4Temp[][4] = + float grad4Temp[][4] = { {0,1,1,1}, {0,1,1,-1}, {0,1,-1,1}, {0,1,-1,-1}, {0,-1,1,1},{0,-1,1,-1},{0,-1,-1,1},{0,-1,-1,-1}, @@ -26,43 +26,42 @@ NzPerlin4D::NzPerlin4D() gradient4[i][j] = grad4Temp[i][j]; } -template -T NzPerlin4D::GetValue(T x, T y, T z, T w, T resolution) +float NzPerlin4D::GetValue(float x, float y, float z, float w, float resolution) { x *= resolution; y *= resolution; z *= resolution; w *= resolution; - x0 = this->fastfloor(x); - y0 = this->fastfloor(y); - z0 = this->fastfloor(z); - w0 = this->fastfloor(w); + x0 = fastfloor(x); + y0 = fastfloor(y); + z0 = fastfloor(z); + w0 = fastfloor(w); ii = x0 & 255; jj = y0 & 255; kk = z0 & 255; ll = w0 & 255; - gi0 = this->perm[ii + this->perm[jj + this->perm[kk + this->perm[ll]]]] & 31; - gi1 = this->perm[ii + 1 + this->perm[jj + this->perm[kk + this->perm[ll]]]] & 31; - gi2 = this->perm[ii + this->perm[jj + 1 + this->perm[kk + this->perm[ll]]]] & 31; - gi3 = this->perm[ii + 1 + this->perm[jj + 1 + this->perm[kk + this->perm[ll]]]] & 31; + gi0 = perm[ii + perm[jj + perm[kk + perm[ll]]]] & 31; + gi1 = perm[ii + 1 + perm[jj + perm[kk + perm[ll]]]] & 31; + gi2 = perm[ii + perm[jj + 1 + perm[kk + perm[ll]]]] & 31; + gi3 = perm[ii + 1 + perm[jj + 1 + perm[kk + perm[ll]]]] & 31; - gi4 = this->perm[ii + this->perm[jj + + this->perm[kk + 1 + this->perm[ll]]]] & 31; - gi5 = this->perm[ii + 1 + this->perm[jj + + this->perm[kk + 1 + this->perm[ll]]]] & 31; - gi6 = this->perm[ii + this->perm[jj + 1 + this->perm[kk + 1 + this->perm[ll]]]] & 31; - gi7 = this->perm[ii + 1 + this->perm[jj + 1 + this->perm[kk + 1 + this->perm[ll]]]] & 31; + gi4 = perm[ii + perm[jj + + perm[kk + 1 + perm[ll]]]] & 31; + gi5 = perm[ii + 1 + perm[jj + + perm[kk + 1 + perm[ll]]]] & 31; + gi6 = perm[ii + perm[jj + 1 + perm[kk + 1 + perm[ll]]]] & 31; + gi7 = perm[ii + 1 + perm[jj + 1 + perm[kk + 1 + perm[ll]]]] & 31; - gi8 = this->perm[ii + this->perm[jj + this->perm[kk + this->perm[ll + 1]]]] & 31; - gi9 = this->perm[ii + 1 + this->perm[jj + this->perm[kk + this->perm[ll + 1]]]] & 31; - gi10 = this->perm[ii + this->perm[jj + 1 + this->perm[kk + this->perm[ll + 1]]]] & 31; - gi11 = this->perm[ii + 1 + this->perm[jj + 1 + this->perm[kk + this->perm[ll + 1]]]] & 31; + gi8 = perm[ii + perm[jj + perm[kk + perm[ll + 1]]]] & 31; + gi9 = perm[ii + 1 + perm[jj + perm[kk + perm[ll + 1]]]] & 31; + gi10 = perm[ii + perm[jj + 1 + perm[kk + perm[ll + 1]]]] & 31; + gi11 = perm[ii + 1 + perm[jj + 1 + perm[kk + perm[ll + 1]]]] & 31; - gi12 = this->perm[ii + this->perm[jj + this->perm[kk + 1 + this->perm[ll + 1]]]] & 31; - gi13 = this->perm[ii + 1 + this->perm[jj + this->perm[kk + 1 + this->perm[ll + 1]]]] & 31; - gi14 = this->perm[ii + this->perm[jj + 1 + this->perm[kk + 1 + this->perm[ll + 1]]]] & 31; - gi15 = this->perm[ii + 1 + this->perm[jj + 1 + this->perm[kk + 1 + this->perm[ll + 1]]]] & 31; + gi12 = perm[ii + perm[jj + perm[kk + 1 + perm[ll + 1]]]] & 31; + gi13 = perm[ii + 1 + perm[jj + perm[kk + 1 + perm[ll + 1]]]] & 31; + gi14 = perm[ii + perm[jj + 1 + perm[kk + 1 + perm[ll + 1]]]] & 31; + gi15 = perm[ii + 1 + perm[jj + 1 + perm[kk + 1 + perm[ll + 1]]]] & 31; temp.x = x-x0; temp.y = y-y0; @@ -146,5 +145,3 @@ T NzPerlin4D::GetValue(T x, T y, T z, T w, T resolution) return Li13 + Cw*(Li14-Li13); } - -#include diff --git a/include/Nazara/Noise/Simplex2D.inl b/src/Nazara/Noise/Simplex2D.cpp similarity index 78% rename from include/Nazara/Noise/Simplex2D.inl rename to src/Nazara/Noise/Simplex2D.cpp index 0bc9d3d10..26c42eeda 100644 --- a/include/Nazara/Noise/Simplex2D.inl +++ b/src/Nazara/Noise/Simplex2D.cpp @@ -4,12 +4,12 @@ #include #include +#include #include -template -NzSimplex2D::NzSimplex2D() +NzSimplex2D::NzSimplex2D() { - T grad2Temp[][2] = {{1,1},{-1,1},{1,-1},{-1,-1}, + float grad2Temp[][2] = {{1,1},{-1,1},{1,-1},{-1,-1}, {1,0},{-1,0},{0,1},{0,-1}}; for(int i(0) ; i < 8 ; ++i) @@ -20,15 +20,14 @@ NzSimplex2D::NzSimplex2D() UnskewCoeff2D = (3.0-sqrt(3.0))/6.; } -template -T NzSimplex2D::GetValue(T x, T y, T resolution) +float NzSimplex2D::GetValue(float x, float y, float resolution) { x *= resolution; y *= resolution; sum = (x + y) * SkewCoeff2D; - skewedCubeOrigin.x = this->fastfloor(x + sum); - skewedCubeOrigin.y = this->fastfloor(y + sum); + skewedCubeOrigin.x = fastfloor(x + sum); + skewedCubeOrigin.y = fastfloor(y + sum); sum = (skewedCubeOrigin.x + skewedCubeOrigin.y) * UnskewCoeff2D; unskewedCubeOrigin.x = skewedCubeOrigin.x - sum; @@ -59,9 +58,9 @@ T NzSimplex2D::GetValue(T x, T y, T resolution) ii = skewedCubeOrigin.x & 255; jj = skewedCubeOrigin.y & 255; - gi0 = this->perm[ii + this->perm[jj ]] & 7; - gi1 = this->perm[ii + off1.x + this->perm[jj + off1.y]] & 7; - gi2 = this->perm[ii + 1 + this->perm[jj + 1 ]] & 7; + gi0 = perm[ii + perm[jj ]] & 7; + gi1 = perm[ii + off1.x + perm[jj + off1.y]] & 7; + gi2 = perm[ii + 1 + perm[jj + 1 ]] & 7; c1 = 0.5 - d1.x * d1.x - d1.y * d1.y; c2 = 0.5 - d2.x * d2.x - d2.y * d2.y; @@ -84,5 +83,3 @@ T NzSimplex2D::GetValue(T x, T y, T resolution) return (n1+n2+n3)*70; } - -#include diff --git a/include/Nazara/Noise/Simplex3D.inl b/src/Nazara/Noise/Simplex3D.cpp similarity index 84% rename from include/Nazara/Noise/Simplex3D.inl rename to src/Nazara/Noise/Simplex3D.cpp index e307c7816..a68739f30 100644 --- a/include/Nazara/Noise/Simplex3D.inl +++ b/src/Nazara/Noise/Simplex3D.cpp @@ -4,10 +4,10 @@ #include #include +#include #include -template -NzSimplex3D::NzSimplex3D() +NzSimplex3D::NzSimplex3D() { SkewCoeff3D = 1/3.; UnskewCoeff3D = 1/6.; @@ -21,17 +21,16 @@ NzSimplex3D::NzSimplex3D() gradient3[i][j] = grad3Temp[i][j]; } -template -T NzSimplex3D::GetValue(T x, T y, T z, T resolution) +float NzSimplex3D::GetValue(float x, float y, float z, float resolution) { x *= resolution; y *= resolution; z *= resolution; sum = (x + y + z) * SkewCoeff3D; - skewedCubeOrigin.x = this->fastfloor(x + sum); - skewedCubeOrigin.y = this->fastfloor(y + sum); - skewedCubeOrigin.z = this->fastfloor(z + sum); + skewedCubeOrigin.x = fastfloor(x + sum); + skewedCubeOrigin.y = fastfloor(y + sum); + skewedCubeOrigin.z = fastfloor(z + sum); sum = (skewedCubeOrigin.x + skewedCubeOrigin.y + skewedCubeOrigin.z) * UnskewCoeff3D; unskewedCubeOrigin.x = skewedCubeOrigin.x - sum; @@ -121,10 +120,10 @@ T NzSimplex3D::GetValue(T x, T y, T z, T resolution) jj = skewedCubeOrigin.y & 255; kk = skewedCubeOrigin.z & 255; - gi0 = this->perm[ii + this->perm[jj + this->perm[kk ]]] % 12; - gi1 = this->perm[ii + off1.x + this->perm[jj + off1.y + this->perm[kk + off1.z]]] % 12; - gi2 = this->perm[ii + off2.x + this->perm[jj + off2.y + this->perm[kk + off2.z]]] % 12; - gi3 = this->perm[ii + 1 + this->perm[jj + 1 + this->perm[kk + 1 ]]] % 12; + gi0 = perm[ii + perm[jj + perm[kk ]]] % 12; + gi1 = perm[ii + off1.x + perm[jj + off1.y + perm[kk + off1.z]]] % 12; + gi2 = perm[ii + off2.x + perm[jj + off2.y + perm[kk + off2.z]]] % 12; + gi3 = perm[ii + 1 + perm[jj + 1 + perm[kk + 1 ]]] % 12; c1 = 0.6 - d1.x * d1.x - d1.y * d1.y - d1.z * d1.z; c2 = 0.6 - d2.x * d2.x - d2.y * d2.y - d2.z * d2.z; @@ -153,5 +152,3 @@ T NzSimplex3D::GetValue(T x, T y, T z, T resolution) return (n1+n2+n3+n4)*32; } - -#include diff --git a/include/Nazara/Noise/Simplex4D.inl b/src/Nazara/Noise/Simplex4D.cpp similarity index 85% rename from include/Nazara/Noise/Simplex4D.inl rename to src/Nazara/Noise/Simplex4D.cpp index 7e28895b6..62f671e34 100644 --- a/include/Nazara/Noise/Simplex4D.inl +++ b/src/Nazara/Noise/Simplex4D.cpp @@ -4,10 +4,10 @@ #include #include +#include #include -template -NzSimplex4D::NzSimplex4D() +NzSimplex4D::NzSimplex4D() { SkewCoeff4D = (sqrt(5.) - 1.)/4.; UnskewCoeff4D = (5. - sqrt(5.))/20.; @@ -45,8 +45,7 @@ NzSimplex4D::NzSimplex4D() gradient4[i][j] = grad4Temp[i][j]; } -template -T NzSimplex4D::GetValue(T x, T y, T z, T w, T resolution) +float NzSimplex4D::GetValue(float x, float y, float z, float w, float resolution) { x *= resolution; y *= resolution; @@ -54,10 +53,10 @@ T NzSimplex4D::GetValue(T x, T y, T z, T w, T resolution) w *= resolution; sum = (x + y + z + w) * SkewCoeff4D; - skewedCubeOrigin.x = this->fastfloor(x + sum); - skewedCubeOrigin.y = this->fastfloor(y + sum); - skewedCubeOrigin.z = this->fastfloor(z + sum); - skewedCubeOrigin.w = this->fastfloor(w + sum); + skewedCubeOrigin.x = fastfloor(x + sum); + skewedCubeOrigin.y = fastfloor(y + sum); + skewedCubeOrigin.z = fastfloor(z + sum); + skewedCubeOrigin.w = fastfloor(w + sum); sum = (skewedCubeOrigin.x + skewedCubeOrigin.y + skewedCubeOrigin.z + skewedCubeOrigin.w) * UnskewCoeff4D; unskewedCubeOrigin.x = skewedCubeOrigin.x - sum; @@ -120,11 +119,11 @@ T NzSimplex4D::GetValue(T x, T y, T z, T w, T resolution) kk = skewedCubeOrigin.z & 255; ll = skewedCubeOrigin.w & 255; - gi0 = this->perm[ii + this->perm[jj + this->perm[kk + this->perm[ll]]]] & 31; - gi1 = this->perm[ii + off1.x + this->perm[jj + off1.y + this->perm[kk + off1.z + this->perm[ll + off1.w]]]] & 31; - gi2 = this->perm[ii + off2.x + this->perm[jj + off2.y + this->perm[kk + off2.z + this->perm[ll + off2.w]]]] & 31; - gi3 = this->perm[ii + off3.x + this->perm[jj + off3.y + this->perm[kk + off3.z + this->perm[ll + off3.w]]]] & 31; - gi4 = this->perm[ii + 1 + this->perm[jj + 1 + this->perm[kk + 1 + this->perm[ll + 1]]]] % 32; + gi0 = perm[ii + perm[jj + perm[kk + perm[ll]]]] & 31; + gi1 = perm[ii + off1.x + perm[jj + off1.y + perm[kk + off1.z + perm[ll + off1.w]]]] & 31; + gi2 = perm[ii + off2.x + perm[jj + off2.y + perm[kk + off2.z + perm[ll + off2.w]]]] & 31; + gi3 = perm[ii + off3.x + perm[jj + off3.y + perm[kk + off3.z + perm[ll + off3.w]]]] & 31; + gi4 = perm[ii + 1 + perm[jj + 1 + perm[kk + 1 + perm[ll + 1]]]] % 32; c1 = 0.6 - d1.x*d1.x - d1.y*d1.y - d1.z*d1.z - d1.w*d1.w; c2 = 0.6 - d2.x*d2.x - d2.y*d2.y - d2.z*d2.z - d2.w*d2.w; @@ -159,5 +158,3 @@ T NzSimplex4D::GetValue(T x, T y, T z, T w, T resolution) return (n1+n2+n3+n4+n5)*27.0; } - -#include From 8f04f3e6a0dda265b9f91ce7563b09df38b09760 Mon Sep 17 00:00:00 2001 From: Remi Beges Date: Fri, 9 Nov 2012 18:38:50 +0100 Subject: [PATCH 12/14] Added FBM 3D & 4D and HybridMultiFractal 2D + cleaned code this commit will change the scale of values produced by fbm2d. This will probably not happen again. As a consequence, fbm values will always be constrained between -1 and 1, but do not perfectly stick to that scale. There is no easy solution, if the user wants the best dynamic between -1 and 1, he should adjust manually the value by multiplying by a gain slightly superior to 1. Former-commit-id: ebdba9e9f4bbb972abe355c07ec9f8bce42329b9 --- include/Nazara/Noise/ComplexNoiseBase.hpp | 2 +- include/Nazara/Noise/FBM2D.hpp | 6 +- include/Nazara/Noise/FBM3D.hpp | 29 +++++++++ include/Nazara/Noise/FBM4D.hpp | 29 +++++++++ include/Nazara/Noise/HybridMultifractal2D.hpp | 29 +++++++++ src/Nazara/Noise/ComplexNoiseBase.cpp | 9 ++- src/Nazara/Noise/FBM2D.cpp | 27 +++----- src/Nazara/Noise/FBM3D.cpp | 51 +++++++++++++++ src/Nazara/Noise/FBM4D.cpp | 51 +++++++++++++++ src/Nazara/Noise/HybridMultifractal2D.cpp | 65 +++++++++++++++++++ 10 files changed, 270 insertions(+), 28 deletions(-) create mode 100644 include/Nazara/Noise/FBM3D.hpp create mode 100644 include/Nazara/Noise/FBM4D.hpp create mode 100644 include/Nazara/Noise/HybridMultifractal2D.hpp create mode 100644 src/Nazara/Noise/FBM3D.cpp create mode 100644 src/Nazara/Noise/FBM4D.cpp create mode 100644 src/Nazara/Noise/HybridMultifractal2D.cpp diff --git a/include/Nazara/Noise/ComplexNoiseBase.hpp b/include/Nazara/Noise/ComplexNoiseBase.hpp index 95ff6a6e7..edd2b4f09 100644 --- a/include/Nazara/Noise/ComplexNoiseBase.hpp +++ b/include/Nazara/Noise/ComplexNoiseBase.hpp @@ -29,7 +29,7 @@ class NAZARA_API NzComplexNoiseBase float m_lacunarity; float m_hurst; float m_octaves; - std::array exponent_array; + std::array m_exponent_array; float m_sum; private: bool m_parametersModified; diff --git a/include/Nazara/Noise/FBM2D.hpp b/include/Nazara/Noise/FBM2D.hpp index 0f2b12e79..a1f8162b4 100644 --- a/include/Nazara/Noise/FBM2D.hpp +++ b/include/Nazara/Noise/FBM2D.hpp @@ -4,8 +4,8 @@ #pragma once -#ifndef FBM2DNOISE_HPP -#define FBM2DNOISE_HPP +#ifndef FBM2D_HPP +#define FBM2D_HPP #include #include @@ -25,4 +25,4 @@ class NAZARA_API NzFBM2D : public NzAbstract2DNoise, public NzComplexNoiseBase nzNoises m_noiseType; }; -#endif // FBM2DNOISE_HPP +#endif // FBM2D_HPP diff --git a/include/Nazara/Noise/FBM3D.hpp b/include/Nazara/Noise/FBM3D.hpp new file mode 100644 index 000000000..18d819209 --- /dev/null +++ b/include/Nazara/Noise/FBM3D.hpp @@ -0,0 +1,29 @@ +// Copyright (C) 2012 Rémi Bèges +// This file is part of the "Nazara Engine". +// For conditions of distribution and use, see copyright notice in Config.hpp + +#pragma once + +#ifndef FBM3D_HPP +#define FBM3D_HPP + +#include +#include +#include + +class NAZARA_API NzFBM3D : public NzAbstract3DNoise, public NzComplexNoiseBase +{ + public: + NzFBM3D(nzNoises source, int seed); + float GetValue(float x, float y, float z, float resolution); + ~NzFBM3D(); + protected: + private: + NzAbstract3DNoise* m_source; + float m_value; + float m_remainder; + nzNoises m_noiseType; +}; + +#endif // FBM3D_HPP + diff --git a/include/Nazara/Noise/FBM4D.hpp b/include/Nazara/Noise/FBM4D.hpp new file mode 100644 index 000000000..100bd79ed --- /dev/null +++ b/include/Nazara/Noise/FBM4D.hpp @@ -0,0 +1,29 @@ +// Copyright (C) 2012 Rémi Bèges +// This file is part of the "Nazara Engine". +// For conditions of distribution and use, see copyright notice in Config.hpp + +#pragma once + +#ifndef FBM4D_HPP +#define FBM4D_HPP + +#include +#include +#include + +class NAZARA_API NzFBM4D : public NzAbstract4DNoise, public NzComplexNoiseBase +{ + public: + NzFBM4D(nzNoises source, int seed); + float GetValue(float x, float y, float z, float w, float resolution); + ~NzFBM4D(); + protected: + private: + NzAbstract4DNoise* m_source; + float m_value; + float m_remainder; + nzNoises m_noiseType; +}; + +#endif // FBM4D_HPP + diff --git a/include/Nazara/Noise/HybridMultifractal2D.hpp b/include/Nazara/Noise/HybridMultifractal2D.hpp new file mode 100644 index 000000000..84b6ac4af --- /dev/null +++ b/include/Nazara/Noise/HybridMultifractal2D.hpp @@ -0,0 +1,29 @@ +// Copyright (C) 2012 Rémi Bèges +// This file is part of the "Nazara Engine". +// For conditions of distribution and use, see copyright notice in Config.hpp + +#pragma once + +#ifndef HYBRIDMULTIFRACTAL2D_HPP +#define HYBRIDMULTIFRACTAL2D_HPP + +#include +#include +#include + +class NAZARA_API NzHybridMultiFractal2D : public NzAbstract2DNoise, public NzComplexNoiseBase +{ + public: + NzHybridMultiFractal2D(nzNoises source, int seed); + float GetValue(float x, float y, float resolution); + ~NzHybridMultiFractal2D(); + protected: + private: + NzAbstract2DNoise* m_source; + float m_value; + float m_remainder; + nzNoises m_noiseType; +}; + +#endif // HYBRIDMULTIFRACTAL2D_HPP + diff --git a/src/Nazara/Noise/ComplexNoiseBase.cpp b/src/Nazara/Noise/ComplexNoiseBase.cpp index b3284f480..946b4f5d0 100644 --- a/src/Nazara/Noise/ComplexNoiseBase.cpp +++ b/src/Nazara/Noise/ComplexNoiseBase.cpp @@ -17,13 +17,13 @@ NzComplexNoiseBase::NzComplexNoiseBase() for (int i(0) ; i < m_octaves; ++i) { - exponent_array[i] = 0; + m_exponent_array[i] = 0; } } const std::array& NzComplexNoiseBase::GetExponentArray() const { - return exponent_array; + return m_exponent_array; } float NzComplexNoiseBase::GetLacunarity() const @@ -80,11 +80,10 @@ void NzComplexNoiseBase::RecomputeExponentArray() for (int i(0) ; i < static_cast(m_octaves) ; ++i) { - exponent_array[i] = std::pow( frequency, -m_hurst ); + m_exponent_array[i] = std::pow( frequency, -m_hurst ); frequency *= m_lacunarity; - //m_sum += 1.0f/exponent_array[i];//A tester - m_sum += exponent_array[i]; + m_sum += m_exponent_array[i]; } m_parametersModified = false; diff --git a/src/Nazara/Noise/FBM2D.cpp b/src/Nazara/Noise/FBM2D.cpp index a5b0a494d..6d86127ee 100644 --- a/src/Nazara/Noise/FBM2D.cpp +++ b/src/Nazara/Noise/FBM2D.cpp @@ -32,31 +32,20 @@ float NzFBM2D::GetValue(float x, float y, float resolution) m_value = 0.0; - for (int i(0); i < this->m_octaves; ++i) + for (int i(0); i < m_octaves; ++i) { - m_value += m_source->GetValue(x,y,resolution) * this->exponent_array[i]; - resolution *= this->m_lacunarity; + m_value += m_source->GetValue(x,y,resolution) * m_exponent_array[i]; + resolution *= m_lacunarity; } - //cout<m_sum<m_octaves - static_cast(this->m_octaves); + m_remainder = m_octaves - static_cast(m_octaves); - //if(!NzNumberEquals(remainder, static_cast(0.0))) - // m_value += remainder * Get2DSimplexNoiseValue(x,y,resolution) * exponent_array[(int)m_octaves-1]; + if(!NzNumberEquals(m_remainder, static_cast(0.0))) + m_value += m_remainder * m_source->GetValue(x,y,resolution) * m_exponent_array[static_cast(m_octaves-1)]; - //0.65 is an experimental value to make the noise stick closer to [-1 , 1] - return m_value / (this->m_sum * 0.65); + return m_value/this->m_sum; } NzFBM2D::~NzFBM2D() { - switch(m_noiseType) - { - case PERLIN: - delete dynamic_cast(m_source); - break; - - default: - delete dynamic_cast(m_source); - break; - } + delete m_source; } diff --git a/src/Nazara/Noise/FBM3D.cpp b/src/Nazara/Noise/FBM3D.cpp new file mode 100644 index 000000000..76e90617f --- /dev/null +++ b/src/Nazara/Noise/FBM3D.cpp @@ -0,0 +1,51 @@ +// Copyright (C) 2012 Rémi Bèges +// This file is part of the "Nazara Engine". +// For conditions of distribution and use, see copyright notice in Config.hpp + +#include +#include +#include +#include +#include +#include + +NzFBM3D::NzFBM3D(nzNoises source, int seed) +{ + switch(source) + { + case PERLIN: + m_source = new NzPerlin3D(); + break; + + default: + m_source = new NzSimplex3D(); + break; + } + m_source->SetNewSeed(seed); + m_source->ShufflePermutationTable(); + m_noiseType = source; +} + +float NzFBM3D::GetValue(float x, float y, float z, float resolution) +{ + this->RecomputeExponentArray(); + + m_value = 0.0; + + for (int i(0); i < m_octaves; ++i) + { + m_value += m_source->GetValue(x,y,z,resolution) * m_exponent_array[i]; + resolution *= m_lacunarity; + } + m_remainder = m_octaves - static_cast(m_octaves); + + if(!NzNumberEquals(m_remainder, static_cast(0.0))) + m_value += m_remainder * m_source->GetValue(x,y,z,resolution) * m_exponent_array[static_cast(m_octaves-1)]; + + return m_value/this->m_sum; +} + +NzFBM3D::~NzFBM3D() +{ + delete m_source; +} diff --git a/src/Nazara/Noise/FBM4D.cpp b/src/Nazara/Noise/FBM4D.cpp new file mode 100644 index 000000000..086341474 --- /dev/null +++ b/src/Nazara/Noise/FBM4D.cpp @@ -0,0 +1,51 @@ +// Copyright (C) 2012 Rémi Bèges +// This file is part of the "Nazara Engine". +// For conditions of distribution and use, see copyright notice in Config.hpp + +#include +#include +#include +#include +#include +#include + +NzFBM4D::NzFBM4D(nzNoises source, int seed) +{ + switch(source) + { + case PERLIN: + m_source = new NzPerlin4D(); + break; + + default: + m_source = new NzSimplex4D(); + break; + } + m_source->SetNewSeed(seed); + m_source->ShufflePermutationTable(); + m_noiseType = source; +} + +float NzFBM4D::GetValue(float x, float y, float z, float w, float resolution) +{ + this->RecomputeExponentArray(); + + m_value = 0.0; + + for (int i(0); i < m_octaves; ++i) + { + m_value += m_source->GetValue(x,y,z,w,resolution) * m_exponent_array[i]; + resolution *= m_lacunarity; + } + m_remainder = m_octaves - static_cast(m_octaves); + + if(!NzNumberEquals(m_remainder, static_cast(0.0))) + m_value += m_remainder * m_source->GetValue(x,y,z,w,resolution) * m_exponent_array[static_cast(m_octaves-1)]; + + return m_value/this->m_sum; +} + +NzFBM4D::~NzFBM4D() +{ + delete m_source; +} diff --git a/src/Nazara/Noise/HybridMultifractal2D.cpp b/src/Nazara/Noise/HybridMultifractal2D.cpp new file mode 100644 index 000000000..cc7975ba2 --- /dev/null +++ b/src/Nazara/Noise/HybridMultifractal2D.cpp @@ -0,0 +1,65 @@ +// Copyright (C) 2012 Rémi Bèges +// This file is part of the "Nazara Engine". +// For conditions of distribution and use, see copyright notice in Config.hpp + +#include +#include +#include +#include +#include +#include + +NzHybridMultiFractal2D::NzHybridMultiFractal2D(nzNoises source, int seed) +{ + switch(source) + { + case PERLIN: + m_source = new NzPerlin2D(); + break; + + default: + m_source = new NzSimplex2D(); + break; + } + m_source->SetNewSeed(seed); + m_source->ShufflePermutationTable(); + m_noiseType = source; +} + +float NzHybridMultiFractal2D::GetValue(float x, float y, float resolution) +{ + this->RecomputeExponentArray(); + + float offset = 1.0f; + + m_value = (m_source->GetValue(x,y,resolution) + offset) * m_exponent_array[0]; + float weight = m_value; + float signal; + + resolution *= m_lacunarity; + + for(int i(1) ; i < m_octaves; ++i) + { + if(weight > 1.0) + weight = 1.0; + + signal = (m_source->GetValue(x,y,resolution) + offset) * m_exponent_array[i]; + m_value += weight * signal; + + weight *= signal; + + resolution *= m_lacunarity; + } + + m_remainder = m_octaves - static_cast(m_octaves); + + if(remainder != 0) + m_value += m_remainder * m_source->GetValue(x,y,resolution) * m_exponent_array[static_cast(m_octaves-1)]; + + return m_value/this->m_sum; +} + +NzHybridMultiFractal2D::~NzHybridMultiFractal2D() +{ + delete m_source; +} From a0b7364eed8c39d0535eda105f550a9e8f544cd2 Mon Sep 17 00:00:00 2001 From: Remi Beges Date: Tue, 13 Nov 2012 19:27:48 +0100 Subject: [PATCH 13/14] Added HybridMultiF 3D & 4D *new constructors for simple noises *minor bufixes Former-commit-id: 2f1e9b6b54087e79b3ac52fefc9bbd67fd45c0eb --- include/Nazara/Noise/HybridMultiFractal3D.hpp | 32 +++++++++ include/Nazara/Noise/HybridMultiFractal4D.hpp | 32 +++++++++ include/Nazara/Noise/HybridMultifractal2D.hpp | 3 + include/Nazara/Noise/Perlin2D.hpp | 1 + include/Nazara/Noise/Perlin3D.hpp | 1 + include/Nazara/Noise/Perlin4D.hpp | 1 + include/Nazara/Noise/Simplex2D.hpp | 1 + include/Nazara/Noise/Simplex3D.hpp | 1 + include/Nazara/Noise/Simplex4D.hpp | 1 + src/Nazara/Noise/HybridMultiFractal3D.cpp | 65 +++++++++++++++++++ src/Nazara/Noise/HybridMultiFractal4D.cpp | 65 +++++++++++++++++++ src/Nazara/Noise/HybridMultifractal2D.cpp | 20 +++--- src/Nazara/Noise/Perlin2D.cpp | 6 ++ src/Nazara/Noise/Perlin3D.cpp | 6 ++ src/Nazara/Noise/Perlin4D.cpp | 6 ++ src/Nazara/Noise/Simplex2D.cpp | 6 ++ src/Nazara/Noise/Simplex3D.cpp | 6 ++ src/Nazara/Noise/Simplex4D.cpp | 6 ++ 18 files changed, 249 insertions(+), 10 deletions(-) create mode 100644 include/Nazara/Noise/HybridMultiFractal3D.hpp create mode 100644 include/Nazara/Noise/HybridMultiFractal4D.hpp create mode 100644 src/Nazara/Noise/HybridMultiFractal3D.cpp create mode 100644 src/Nazara/Noise/HybridMultiFractal4D.cpp diff --git a/include/Nazara/Noise/HybridMultiFractal3D.hpp b/include/Nazara/Noise/HybridMultiFractal3D.hpp new file mode 100644 index 000000000..d02d171dc --- /dev/null +++ b/include/Nazara/Noise/HybridMultiFractal3D.hpp @@ -0,0 +1,32 @@ +// Copyright (C) 2012 Rémi Bèges +// This file is part of the "Nazara Engine". +// For conditions of distribution and use, see copyright notice in Config.hpp + +#pragma once + +#ifndef HYBRIDMULTIFRACTAL3D_HPP +#define HYBRIDMULTIFRACTAL3D_HPP + +#include +#include +#include + +class NAZARA_API NzHybridMultiFractal3D : public NzAbstract3DNoise, public NzComplexNoiseBase +{ + public: + NzHybridMultiFractal3D(nzNoises source, int seed); + float GetValue(float x, float y, float z, float resolution); + ~NzHybridMultiFractal3D(); + protected: + private: + NzAbstract3DNoise* m_source; + float m_value; + float m_remainder; + float m_offset; + float m_weight; + float m_signal; + nzNoises m_noiseType; +}; + +#endif // HYBRIDMULTIFRACTAL3D_HPP + diff --git a/include/Nazara/Noise/HybridMultiFractal4D.hpp b/include/Nazara/Noise/HybridMultiFractal4D.hpp new file mode 100644 index 000000000..7b49d45d6 --- /dev/null +++ b/include/Nazara/Noise/HybridMultiFractal4D.hpp @@ -0,0 +1,32 @@ +// Copyright (C) 2012 Rémi Bèges +// This file is part of the "Nazara Engine". +// For conditions of distribution and use, see copyright notice in Config.hpp + +#pragma once + +#ifndef HYBRIDMULTIFRACTAL4D_HPP +#define HYBRIDMULTIFRACTAL4D_HPP + +#include +#include +#include + +class NAZARA_API NzHybridMultiFractal4D : public NzAbstract4DNoise, public NzComplexNoiseBase +{ + public: + NzHybridMultiFractal4D(nzNoises source, int seed); + float GetValue(float x, float y, float z, float w, float resolution); + ~NzHybridMultiFractal4D(); + protected: + private: + NzAbstract4DNoise* m_source; + float m_value; + float m_remainder; + float m_offset; + float m_weight; + float m_signal; + nzNoises m_noiseType; +}; + +#endif // HYBRIDMULTIFRACTAL4D_HPP + diff --git a/include/Nazara/Noise/HybridMultifractal2D.hpp b/include/Nazara/Noise/HybridMultifractal2D.hpp index 84b6ac4af..2f13e28e5 100644 --- a/include/Nazara/Noise/HybridMultifractal2D.hpp +++ b/include/Nazara/Noise/HybridMultifractal2D.hpp @@ -22,6 +22,9 @@ class NAZARA_API NzHybridMultiFractal2D : public NzAbstract2DNoise, public NzCom NzAbstract2DNoise* m_source; float m_value; float m_remainder; + float m_offset; + float m_weight; + float m_signal; nzNoises m_noiseType; }; diff --git a/include/Nazara/Noise/Perlin2D.hpp b/include/Nazara/Noise/Perlin2D.hpp index a437020ec..1311801b9 100644 --- a/include/Nazara/Noise/Perlin2D.hpp +++ b/include/Nazara/Noise/Perlin2D.hpp @@ -16,6 +16,7 @@ class NAZARA_API NzPerlin2D : public NzAbstract2DNoise { public: NzPerlin2D(); + NzPerlin2D(int seed); float GetValue(float x, float y, float resolution); ~NzPerlin2D() = default; protected: diff --git a/include/Nazara/Noise/Perlin3D.hpp b/include/Nazara/Noise/Perlin3D.hpp index ada704e9d..613cb8ef1 100644 --- a/include/Nazara/Noise/Perlin3D.hpp +++ b/include/Nazara/Noise/Perlin3D.hpp @@ -16,6 +16,7 @@ class NAZARA_API NzPerlin3D : public NzAbstract3DNoise { public: NzPerlin3D(); + NzPerlin3D(int seed); float GetValue(float x, float y, float z, float resolution); ~NzPerlin3D() = default; protected: diff --git a/include/Nazara/Noise/Perlin4D.hpp b/include/Nazara/Noise/Perlin4D.hpp index 8a04894b4..196968bc2 100644 --- a/include/Nazara/Noise/Perlin4D.hpp +++ b/include/Nazara/Noise/Perlin4D.hpp @@ -16,6 +16,7 @@ class NAZARA_API NzPerlin4D : public NzAbstract4DNoise { public: NzPerlin4D(); + NzPerlin4D(int seed); float GetValue(float x, float y, float z, float w, float resolution); ~NzPerlin4D() = default; protected: diff --git a/include/Nazara/Noise/Simplex2D.hpp b/include/Nazara/Noise/Simplex2D.hpp index c121d0d55..2da63dd65 100644 --- a/include/Nazara/Noise/Simplex2D.hpp +++ b/include/Nazara/Noise/Simplex2D.hpp @@ -16,6 +16,7 @@ class NAZARA_API NzSimplex2D : public NzAbstract2DNoise { public: NzSimplex2D(); + NzSimplex2D(int seed); float GetValue(float x, float y, float resolution); virtual ~NzSimplex2D() = default; protected: diff --git a/include/Nazara/Noise/Simplex3D.hpp b/include/Nazara/Noise/Simplex3D.hpp index a6d636875..84e1d3982 100644 --- a/include/Nazara/Noise/Simplex3D.hpp +++ b/include/Nazara/Noise/Simplex3D.hpp @@ -16,6 +16,7 @@ class NAZARA_API NzSimplex3D : public NzAbstract3DNoise { public: NzSimplex3D(); + NzSimplex3D(int seed); float GetValue(float x, float y, float z, float resolution); ~NzSimplex3D() = default; protected: diff --git a/include/Nazara/Noise/Simplex4D.hpp b/include/Nazara/Noise/Simplex4D.hpp index cf159de79..662e4f258 100644 --- a/include/Nazara/Noise/Simplex4D.hpp +++ b/include/Nazara/Noise/Simplex4D.hpp @@ -16,6 +16,7 @@ class NAZARA_API NzSimplex4D : public NzAbstract4DNoise { public: NzSimplex4D(); + NzSimplex4D(int seed); float GetValue(float x, float y, float z, float w, float resolution); ~NzSimplex4D() = default; protected: diff --git a/src/Nazara/Noise/HybridMultiFractal3D.cpp b/src/Nazara/Noise/HybridMultiFractal3D.cpp new file mode 100644 index 000000000..a6054b1eb --- /dev/null +++ b/src/Nazara/Noise/HybridMultiFractal3D.cpp @@ -0,0 +1,65 @@ +// Copyright (C) 2012 Rémi Bèges +// This file is part of the "Nazara Engine". +// For conditions of distribution and use, see copyright notice in Config.hpp + +#include +#include +#include +#include +#include +#include + +NzHybridMultiFractal3D::NzHybridMultiFractal3D(nzNoises source, int seed) +{ + switch(source) + { + case PERLIN: + m_source = new NzPerlin3D(); + break; + + default: + m_source = new NzSimplex3D(); + break; + } + m_source->SetNewSeed(seed); + m_source->ShufflePermutationTable(); + m_noiseType = source; +} + +float NzHybridMultiFractal3D::GetValue(float x, float y, float z, float resolution) +{ + this->RecomputeExponentArray(); + + m_offset = 1.0f; + + m_value = (m_source->GetValue(x,y,z,resolution) + m_offset) * m_exponent_array[0]; + m_weight = m_value; + m_signal = 0.f; + + resolution *= m_lacunarity; + + for(int i(1) ; i < m_octaves; ++i) + { + if(m_weight > 1.0) + m_weight = 1.0; + + m_signal = (m_source->GetValue(x,y,z,resolution) + m_offset) * m_exponent_array[i]; + m_value += m_weight * m_signal; + + m_weight *= m_signal; + + resolution *= m_lacunarity; + } + + m_remainder = m_octaves - static_cast(m_octaves); + + if(remainder != 0) + m_value += m_remainder * m_source->GetValue(x,y,z,resolution) * m_exponent_array[static_cast(m_octaves-1)]; + + return m_value/this->m_sum - m_offset; +} + +NzHybridMultiFractal3D::~NzHybridMultiFractal3D() +{ + delete m_source; +} diff --git a/src/Nazara/Noise/HybridMultiFractal4D.cpp b/src/Nazara/Noise/HybridMultiFractal4D.cpp new file mode 100644 index 000000000..b23ad0ba0 --- /dev/null +++ b/src/Nazara/Noise/HybridMultiFractal4D.cpp @@ -0,0 +1,65 @@ +// Copyright (C) 2012 Rémi Bèges +// This file is part of the "Nazara Engine". +// For conditions of distribution and use, see copyright notice in Config.hpp + +#include +#include +#include +#include +#include +#include + +NzHybridMultiFractal4D::NzHybridMultiFractal4D(nzNoises source, int seed) +{ + switch(source) + { + case PERLIN: + m_source = new NzPerlin4D(); + break; + + default: + m_source = new NzSimplex4D(); + break; + } + m_source->SetNewSeed(seed); + m_source->ShufflePermutationTable(); + m_noiseType = source; +} + +float NzHybridMultiFractal4D::GetValue(float x, float y, float z, float w, float resolution) +{ + this->RecomputeExponentArray(); + + m_offset = 1.0f; + + m_value = (m_source->GetValue(x,y,z,w,resolution) + m_offset) * m_exponent_array[0]; + m_weight = m_value; + m_signal = 0.f; + + resolution *= m_lacunarity; + + for(int i(1) ; i < m_octaves; ++i) + { + if(m_weight > 1.0) + m_weight = 1.0; + + m_signal = (m_source->GetValue(x,y,z,w,resolution) + m_offset) * m_exponent_array[i]; + m_value += m_weight * m_signal; + + m_weight *= m_signal; + + resolution *= m_lacunarity; + } + + m_remainder = m_octaves - static_cast(m_octaves); + + if(remainder != 0) + m_value += m_remainder * m_source->GetValue(x,y,z,w,resolution) * m_exponent_array[static_cast(m_octaves-1)]; + + return m_value/this->m_sum - m_offset; +} + +NzHybridMultiFractal4D::~NzHybridMultiFractal4D() +{ + delete m_source; +} diff --git a/src/Nazara/Noise/HybridMultifractal2D.cpp b/src/Nazara/Noise/HybridMultifractal2D.cpp index cc7975ba2..012ae3f0f 100644 --- a/src/Nazara/Noise/HybridMultifractal2D.cpp +++ b/src/Nazara/Noise/HybridMultifractal2D.cpp @@ -30,23 +30,23 @@ float NzHybridMultiFractal2D::GetValue(float x, float y, float resolution) { this->RecomputeExponentArray(); - float offset = 1.0f; + m_offset = 1.0f; - m_value = (m_source->GetValue(x,y,resolution) + offset) * m_exponent_array[0]; - float weight = m_value; - float signal; + m_value = (m_source->GetValue(x,y,resolution) + m_offset) * m_exponent_array[0]; + m_weight = m_value; + m_signal = 0.f; resolution *= m_lacunarity; for(int i(1) ; i < m_octaves; ++i) { - if(weight > 1.0) - weight = 1.0; + if(m_weight > 1.0) + m_weight = 1.0; - signal = (m_source->GetValue(x,y,resolution) + offset) * m_exponent_array[i]; - m_value += weight * signal; + m_signal = (m_source->GetValue(x,y,resolution) + m_offset) * m_exponent_array[i]; + m_value += m_weight * m_signal; - weight *= signal; + m_weight *= m_signal; resolution *= m_lacunarity; } @@ -56,7 +56,7 @@ float NzHybridMultiFractal2D::GetValue(float x, float y, float resolution) if(remainder != 0) m_value += m_remainder * m_source->GetValue(x,y,resolution) * m_exponent_array[static_cast(m_octaves-1)]; - return m_value/this->m_sum; + return m_value/this->m_sum - m_offset; } NzHybridMultiFractal2D::~NzHybridMultiFractal2D() diff --git a/src/Nazara/Noise/Perlin2D.cpp b/src/Nazara/Noise/Perlin2D.cpp index 157dab5d4..9ec67fbc7 100644 --- a/src/Nazara/Noise/Perlin2D.cpp +++ b/src/Nazara/Noise/Perlin2D.cpp @@ -17,6 +17,12 @@ NzPerlin2D::NzPerlin2D() gradient2[i][j] = grad2Temp[i][j]; } +NzPerlin2D::NzPerlin2D(int seed) : NzPerlin2D() +{ + this->SetNewSeed(seed); + this->ShufflePermutationTable(); +} + float NzPerlin2D::GetValue(float x, float y, float resolution) { x *= resolution; diff --git a/src/Nazara/Noise/Perlin3D.cpp b/src/Nazara/Noise/Perlin3D.cpp index 774ee7436..aa79e6d1d 100644 --- a/src/Nazara/Noise/Perlin3D.cpp +++ b/src/Nazara/Noise/Perlin3D.cpp @@ -21,6 +21,12 @@ NzPerlin3D::NzPerlin3D() gradient3[i][j] = grad3Temp[i][j]; } +NzPerlin3D::NzPerlin3D(int seed) : NzPerlin3D() +{ + this->SetNewSeed(seed); + this->ShufflePermutationTable(); +} + float NzPerlin3D::GetValue(float x, float y, float z, float resolution) { x /= resolution; diff --git a/src/Nazara/Noise/Perlin4D.cpp b/src/Nazara/Noise/Perlin4D.cpp index 308a4d3fc..69bf03f5b 100644 --- a/src/Nazara/Noise/Perlin4D.cpp +++ b/src/Nazara/Noise/Perlin4D.cpp @@ -26,6 +26,12 @@ NzPerlin4D::NzPerlin4D() gradient4[i][j] = grad4Temp[i][j]; } +NzPerlin4D::NzPerlin4D(int seed) : NzPerlin4D() +{ + this->SetNewSeed(seed); + this->ShufflePermutationTable(); +} + float NzPerlin4D::GetValue(float x, float y, float z, float w, float resolution) { x *= resolution; diff --git a/src/Nazara/Noise/Simplex2D.cpp b/src/Nazara/Noise/Simplex2D.cpp index 26c42eeda..392f44986 100644 --- a/src/Nazara/Noise/Simplex2D.cpp +++ b/src/Nazara/Noise/Simplex2D.cpp @@ -20,6 +20,12 @@ NzSimplex2D::NzSimplex2D() UnskewCoeff2D = (3.0-sqrt(3.0))/6.; } +NzSimplex2D::NzSimplex2D(int seed) : NzSimplex2D() +{ + this->SetNewSeed(seed); + this->ShufflePermutationTable(); +} + float NzSimplex2D::GetValue(float x, float y, float resolution) { x *= resolution; diff --git a/src/Nazara/Noise/Simplex3D.cpp b/src/Nazara/Noise/Simplex3D.cpp index a68739f30..7436add6d 100644 --- a/src/Nazara/Noise/Simplex3D.cpp +++ b/src/Nazara/Noise/Simplex3D.cpp @@ -21,6 +21,12 @@ NzSimplex3D::NzSimplex3D() gradient3[i][j] = grad3Temp[i][j]; } +NzSimplex3D::NzSimplex3D(int seed) : NzSimplex3D() +{ + this->SetNewSeed(seed); + this->ShufflePermutationTable(); +} + float NzSimplex3D::GetValue(float x, float y, float z, float resolution) { x *= resolution; diff --git a/src/Nazara/Noise/Simplex4D.cpp b/src/Nazara/Noise/Simplex4D.cpp index 62f671e34..99d7dd1ed 100644 --- a/src/Nazara/Noise/Simplex4D.cpp +++ b/src/Nazara/Noise/Simplex4D.cpp @@ -45,6 +45,12 @@ NzSimplex4D::NzSimplex4D() gradient4[i][j] = grad4Temp[i][j]; } +NzSimplex4D::NzSimplex4D(int seed) : NzSimplex4D() +{ + this->SetNewSeed(seed); + this->ShufflePermutationTable(); +} + float NzSimplex4D::GetValue(float x, float y, float z, float w, float resolution) { x *= resolution; From d0545eb760e20cccbef609ae4025fe6b42a71bf6 Mon Sep 17 00:00:00 2001 From: Remi Beges Date: Sat, 1 Dec 2012 10:07:41 +0100 Subject: [PATCH 14/14] Minor fixes *Seed is uint instead of int *Permutation table is uint instead of int, could lead before to program crash with negative seeds Former-commit-id: 49ad04987a09a5f5b4bcab6ee3916db9818172b6 --- include/Nazara/Noise/ComplexNoiseBase.hpp | 1 - include/Nazara/Noise/FBM2D.hpp | 2 +- include/Nazara/Noise/FBM3D.hpp | 2 +- include/Nazara/Noise/FBM4D.hpp | 2 +- include/Nazara/Noise/HybridMultiFractal3D.hpp | 2 +- include/Nazara/Noise/HybridMultiFractal4D.hpp | 2 +- include/Nazara/Noise/HybridMultifractal2D.hpp | 2 +- include/Nazara/Noise/Noise.hpp | 29 ----------- include/Nazara/Noise/NoiseBase.hpp | 16 +++--- include/Nazara/Noise/Perlin2D.hpp | 2 +- include/Nazara/Noise/Perlin3D.hpp | 2 +- include/Nazara/Noise/Perlin4D.hpp | 2 +- include/Nazara/Noise/Simplex2D.hpp | 2 +- include/Nazara/Noise/Simplex3D.hpp | 2 +- include/Nazara/Noise/Simplex4D.hpp | 2 +- src/Nazara/Noise/ComplexNoiseBase.cpp | 21 +++----- src/Nazara/Noise/FBM2D.cpp | 2 +- src/Nazara/Noise/FBM3D.cpp | 2 +- src/Nazara/Noise/FBM4D.cpp | 2 +- src/Nazara/Noise/HybridMultiFractal3D.cpp | 2 +- src/Nazara/Noise/HybridMultiFractal4D.cpp | 2 +- src/Nazara/Noise/HybridMultifractal2D.cpp | 2 +- src/Nazara/Noise/Noise.cpp | 49 ------------------- src/Nazara/Noise/NoiseBase.cpp | 16 +++--- src/Nazara/Noise/Perlin2D.cpp | 2 +- src/Nazara/Noise/Perlin3D.cpp | 2 +- src/Nazara/Noise/Perlin4D.cpp | 2 +- src/Nazara/Noise/Simplex2D.cpp | 2 +- src/Nazara/Noise/Simplex3D.cpp | 2 +- src/Nazara/Noise/Simplex4D.cpp | 2 +- 30 files changed, 46 insertions(+), 134 deletions(-) delete mode 100644 include/Nazara/Noise/Noise.hpp delete mode 100644 src/Nazara/Noise/Noise.cpp diff --git a/include/Nazara/Noise/ComplexNoiseBase.hpp b/include/Nazara/Noise/ComplexNoiseBase.hpp index edd2b4f09..0800c5e3f 100644 --- a/include/Nazara/Noise/ComplexNoiseBase.hpp +++ b/include/Nazara/Noise/ComplexNoiseBase.hpp @@ -16,7 +16,6 @@ class NAZARA_API NzComplexNoiseBase NzComplexNoiseBase(); ~NzComplexNoiseBase() = default; - const std::array& GetExponentArray() const; //For debug purpose float GetHurstParameter() const; float GetLacunarity() const; float GetOctaveNumber() const; diff --git a/include/Nazara/Noise/FBM2D.hpp b/include/Nazara/Noise/FBM2D.hpp index a1f8162b4..01c89efd4 100644 --- a/include/Nazara/Noise/FBM2D.hpp +++ b/include/Nazara/Noise/FBM2D.hpp @@ -14,7 +14,7 @@ class NAZARA_API NzFBM2D : public NzAbstract2DNoise, public NzComplexNoiseBase { public: - NzFBM2D(nzNoises source, int seed); + NzFBM2D(nzNoises source, unsigned int seed); float GetValue(float x, float y, float resolution); ~NzFBM2D(); protected: diff --git a/include/Nazara/Noise/FBM3D.hpp b/include/Nazara/Noise/FBM3D.hpp index 18d819209..672108278 100644 --- a/include/Nazara/Noise/FBM3D.hpp +++ b/include/Nazara/Noise/FBM3D.hpp @@ -14,7 +14,7 @@ class NAZARA_API NzFBM3D : public NzAbstract3DNoise, public NzComplexNoiseBase { public: - NzFBM3D(nzNoises source, int seed); + NzFBM3D(nzNoises source, unsigned int seed); float GetValue(float x, float y, float z, float resolution); ~NzFBM3D(); protected: diff --git a/include/Nazara/Noise/FBM4D.hpp b/include/Nazara/Noise/FBM4D.hpp index 100bd79ed..98f75c642 100644 --- a/include/Nazara/Noise/FBM4D.hpp +++ b/include/Nazara/Noise/FBM4D.hpp @@ -14,7 +14,7 @@ class NAZARA_API NzFBM4D : public NzAbstract4DNoise, public NzComplexNoiseBase { public: - NzFBM4D(nzNoises source, int seed); + NzFBM4D(nzNoises source, unsigned int seed); float GetValue(float x, float y, float z, float w, float resolution); ~NzFBM4D(); protected: diff --git a/include/Nazara/Noise/HybridMultiFractal3D.hpp b/include/Nazara/Noise/HybridMultiFractal3D.hpp index d02d171dc..ff9f67787 100644 --- a/include/Nazara/Noise/HybridMultiFractal3D.hpp +++ b/include/Nazara/Noise/HybridMultiFractal3D.hpp @@ -14,7 +14,7 @@ class NAZARA_API NzHybridMultiFractal3D : public NzAbstract3DNoise, public NzComplexNoiseBase { public: - NzHybridMultiFractal3D(nzNoises source, int seed); + NzHybridMultiFractal3D(nzNoises source, unsigned int seed); float GetValue(float x, float y, float z, float resolution); ~NzHybridMultiFractal3D(); protected: diff --git a/include/Nazara/Noise/HybridMultiFractal4D.hpp b/include/Nazara/Noise/HybridMultiFractal4D.hpp index 7b49d45d6..da07e78ef 100644 --- a/include/Nazara/Noise/HybridMultiFractal4D.hpp +++ b/include/Nazara/Noise/HybridMultiFractal4D.hpp @@ -14,7 +14,7 @@ class NAZARA_API NzHybridMultiFractal4D : public NzAbstract4DNoise, public NzComplexNoiseBase { public: - NzHybridMultiFractal4D(nzNoises source, int seed); + NzHybridMultiFractal4D(nzNoises source, unsigned int seed); float GetValue(float x, float y, float z, float w, float resolution); ~NzHybridMultiFractal4D(); protected: diff --git a/include/Nazara/Noise/HybridMultifractal2D.hpp b/include/Nazara/Noise/HybridMultifractal2D.hpp index 2f13e28e5..4a843adf2 100644 --- a/include/Nazara/Noise/HybridMultifractal2D.hpp +++ b/include/Nazara/Noise/HybridMultifractal2D.hpp @@ -14,7 +14,7 @@ class NAZARA_API NzHybridMultiFractal2D : public NzAbstract2DNoise, public NzComplexNoiseBase { public: - NzHybridMultiFractal2D(nzNoises source, int seed); + NzHybridMultiFractal2D(nzNoises source, unsigned int seed); float GetValue(float x, float y, float resolution); ~NzHybridMultiFractal2D(); protected: diff --git a/include/Nazara/Noise/Noise.hpp b/include/Nazara/Noise/Noise.hpp deleted file mode 100644 index 464117ecc..000000000 --- a/include/Nazara/Noise/Noise.hpp +++ /dev/null @@ -1,29 +0,0 @@ -// Copyright (C) 2012 Rémi Bèges -// This file is part of the "Nazara Engine - Noise module" -// For conditions of distribution and use, see copyright notice in Config.hpp - -#pragma once - -#ifndef NAZARA_NOISE_HPP -#define NAZARA_NOISE_HPP - -#include -#include - -class NAZARA_API NzNoise -{ - public: - NzNoise() = delete; - ~NzNoise() = delete; - - static bool Initialize(); - - static bool IsInitialized(); - - static void Uninitialize(); - - private: - static unsigned int s_moduleReferenceCouter; -}; - -#endif // NAZARA_NOISE_HPP diff --git a/include/Nazara/Noise/NoiseBase.hpp b/include/Nazara/Noise/NoiseBase.hpp index 13b480093..694b4b597 100644 --- a/include/Nazara/Noise/NoiseBase.hpp +++ b/include/Nazara/Noise/NoiseBase.hpp @@ -19,21 +19,23 @@ enum nzNoises class NAZARA_API NzNoiseBase { public: - NzNoiseBase(int seed = 0); + NzNoiseBase(unsigned int seed = 0); ~NzNoiseBase() = default; - void SetNewSeed(int seed); - int GetUniformRandomValue(); + void SetNewSeed(unsigned int seed); + void ShufflePermutationTable(); + unsigned int GetUniformRandomValue(); + int fastfloor(float n); int JenkinsHash(int a, int b, int c); protected: - int perm[512]; + unsigned int perm[512]; private: - int Ua, Uc, Um; - int UcurrentSeed; - int Uprevious, Ulast; + unsigned int Ua, Uc, Um; + unsigned int UcurrentSeed; + unsigned int Uprevious, Ulast; }; diff --git a/include/Nazara/Noise/Perlin2D.hpp b/include/Nazara/Noise/Perlin2D.hpp index 1311801b9..dca50ebdd 100644 --- a/include/Nazara/Noise/Perlin2D.hpp +++ b/include/Nazara/Noise/Perlin2D.hpp @@ -16,7 +16,7 @@ class NAZARA_API NzPerlin2D : public NzAbstract2DNoise { public: NzPerlin2D(); - NzPerlin2D(int seed); + NzPerlin2D(unsigned int seed); float GetValue(float x, float y, float resolution); ~NzPerlin2D() = default; protected: diff --git a/include/Nazara/Noise/Perlin3D.hpp b/include/Nazara/Noise/Perlin3D.hpp index 613cb8ef1..97c6b0ec3 100644 --- a/include/Nazara/Noise/Perlin3D.hpp +++ b/include/Nazara/Noise/Perlin3D.hpp @@ -16,7 +16,7 @@ class NAZARA_API NzPerlin3D : public NzAbstract3DNoise { public: NzPerlin3D(); - NzPerlin3D(int seed); + NzPerlin3D(unsigned int seed); float GetValue(float x, float y, float z, float resolution); ~NzPerlin3D() = default; protected: diff --git a/include/Nazara/Noise/Perlin4D.hpp b/include/Nazara/Noise/Perlin4D.hpp index 196968bc2..ade11217e 100644 --- a/include/Nazara/Noise/Perlin4D.hpp +++ b/include/Nazara/Noise/Perlin4D.hpp @@ -16,7 +16,7 @@ class NAZARA_API NzPerlin4D : public NzAbstract4DNoise { public: NzPerlin4D(); - NzPerlin4D(int seed); + NzPerlin4D(unsigned int seed); float GetValue(float x, float y, float z, float w, float resolution); ~NzPerlin4D() = default; protected: diff --git a/include/Nazara/Noise/Simplex2D.hpp b/include/Nazara/Noise/Simplex2D.hpp index 2da63dd65..f47962046 100644 --- a/include/Nazara/Noise/Simplex2D.hpp +++ b/include/Nazara/Noise/Simplex2D.hpp @@ -16,7 +16,7 @@ class NAZARA_API NzSimplex2D : public NzAbstract2DNoise { public: NzSimplex2D(); - NzSimplex2D(int seed); + NzSimplex2D(unsigned int seed); float GetValue(float x, float y, float resolution); virtual ~NzSimplex2D() = default; protected: diff --git a/include/Nazara/Noise/Simplex3D.hpp b/include/Nazara/Noise/Simplex3D.hpp index 84e1d3982..14d118225 100644 --- a/include/Nazara/Noise/Simplex3D.hpp +++ b/include/Nazara/Noise/Simplex3D.hpp @@ -16,7 +16,7 @@ class NAZARA_API NzSimplex3D : public NzAbstract3DNoise { public: NzSimplex3D(); - NzSimplex3D(int seed); + NzSimplex3D(unsigned int seed); float GetValue(float x, float y, float z, float resolution); ~NzSimplex3D() = default; protected: diff --git a/include/Nazara/Noise/Simplex4D.hpp b/include/Nazara/Noise/Simplex4D.hpp index 662e4f258..e1e7a1889 100644 --- a/include/Nazara/Noise/Simplex4D.hpp +++ b/include/Nazara/Noise/Simplex4D.hpp @@ -16,7 +16,7 @@ class NAZARA_API NzSimplex4D : public NzAbstract4DNoise { public: NzSimplex4D(); - NzSimplex4D(int seed); + NzSimplex4D(unsigned int seed); float GetValue(float x, float y, float z, float w, float resolution); ~NzSimplex4D() = default; protected: diff --git a/src/Nazara/Noise/ComplexNoiseBase.cpp b/src/Nazara/Noise/ComplexNoiseBase.cpp index 946b4f5d0..14d00ea37 100644 --- a/src/Nazara/Noise/ComplexNoiseBase.cpp +++ b/src/Nazara/Noise/ComplexNoiseBase.cpp @@ -21,11 +21,6 @@ NzComplexNoiseBase::NzComplexNoiseBase() } } -const std::array& NzComplexNoiseBase::GetExponentArray() const -{ - return m_exponent_array; -} - float NzComplexNoiseBase::GetLacunarity() const { @@ -44,20 +39,16 @@ float NzComplexNoiseBase::GetOctaveNumber() const void NzComplexNoiseBase::SetLacunarity(float lacunarity) { - // if(lacunarity != m_lacunarity) - //{ - m_lacunarity = lacunarity; - m_parametersModified = true; - //} + m_lacunarity = lacunarity; + m_parametersModified = true; + } void NzComplexNoiseBase::SetHurstParameter(float h) { - //if(h != m_hurst) - //{ - m_hurst = h; - m_parametersModified = true; - //} + + m_hurst = h; + m_parametersModified = true; } void NzComplexNoiseBase::SetOctavesNumber(float octaves) diff --git a/src/Nazara/Noise/FBM2D.cpp b/src/Nazara/Noise/FBM2D.cpp index 6d86127ee..0e9e89dc9 100644 --- a/src/Nazara/Noise/FBM2D.cpp +++ b/src/Nazara/Noise/FBM2D.cpp @@ -9,7 +9,7 @@ #include #include -NzFBM2D::NzFBM2D(nzNoises source, int seed) +NzFBM2D::NzFBM2D(nzNoises source, unsigned int seed) { switch(source) { diff --git a/src/Nazara/Noise/FBM3D.cpp b/src/Nazara/Noise/FBM3D.cpp index 76e90617f..3423c25b5 100644 --- a/src/Nazara/Noise/FBM3D.cpp +++ b/src/Nazara/Noise/FBM3D.cpp @@ -9,7 +9,7 @@ #include #include -NzFBM3D::NzFBM3D(nzNoises source, int seed) +NzFBM3D::NzFBM3D(nzNoises source, unsigned int seed) { switch(source) { diff --git a/src/Nazara/Noise/FBM4D.cpp b/src/Nazara/Noise/FBM4D.cpp index 086341474..d63cbbf13 100644 --- a/src/Nazara/Noise/FBM4D.cpp +++ b/src/Nazara/Noise/FBM4D.cpp @@ -9,7 +9,7 @@ #include #include -NzFBM4D::NzFBM4D(nzNoises source, int seed) +NzFBM4D::NzFBM4D(nzNoises source, unsigned int seed) { switch(source) { diff --git a/src/Nazara/Noise/HybridMultiFractal3D.cpp b/src/Nazara/Noise/HybridMultiFractal3D.cpp index a6054b1eb..ccb85ee8e 100644 --- a/src/Nazara/Noise/HybridMultiFractal3D.cpp +++ b/src/Nazara/Noise/HybridMultiFractal3D.cpp @@ -9,7 +9,7 @@ #include #include -NzHybridMultiFractal3D::NzHybridMultiFractal3D(nzNoises source, int seed) +NzHybridMultiFractal3D::NzHybridMultiFractal3D(nzNoises source, unsigned int seed) { switch(source) { diff --git a/src/Nazara/Noise/HybridMultiFractal4D.cpp b/src/Nazara/Noise/HybridMultiFractal4D.cpp index b23ad0ba0..2132ac520 100644 --- a/src/Nazara/Noise/HybridMultiFractal4D.cpp +++ b/src/Nazara/Noise/HybridMultiFractal4D.cpp @@ -9,7 +9,7 @@ #include #include -NzHybridMultiFractal4D::NzHybridMultiFractal4D(nzNoises source, int seed) +NzHybridMultiFractal4D::NzHybridMultiFractal4D(nzNoises source, unsigned int seed) { switch(source) { diff --git a/src/Nazara/Noise/HybridMultifractal2D.cpp b/src/Nazara/Noise/HybridMultifractal2D.cpp index 012ae3f0f..a789e57e1 100644 --- a/src/Nazara/Noise/HybridMultifractal2D.cpp +++ b/src/Nazara/Noise/HybridMultifractal2D.cpp @@ -9,7 +9,7 @@ #include #include -NzHybridMultiFractal2D::NzHybridMultiFractal2D(nzNoises source, int seed) +NzHybridMultiFractal2D::NzHybridMultiFractal2D(nzNoises source, unsigned int seed) { switch(source) { diff --git a/src/Nazara/Noise/Noise.cpp b/src/Nazara/Noise/Noise.cpp deleted file mode 100644 index a38a8346d..000000000 --- a/src/Nazara/Noise/Noise.cpp +++ /dev/null @@ -1,49 +0,0 @@ -// Copyright (C) 2012 Rémi Bèges -// This file is part of the "Nazara Engine - Noise module" -// For conditions of distribution and use, see copyright notice in Config.hpp - -#include -#include -#include -#include -#include -#include - -bool NzNoise::Initialize() -{ - if (s_moduleReferenceCouter++ != 0) - return true; // Déjà initialisé - - // Initialisation des dépendances - if (!NzCore::Initialize()) - { - NazaraError("Failed to initialize core module"); - return false; - } - - // Initialisation du module - - NazaraNotice("Initialized: Noise module"); - - return true; -} - -bool NzNoise::IsInitialized() -{ - return s_moduleReferenceCouter != 0; -} - -void NzNoise::Uninitialize() -{ - if (--s_moduleReferenceCouter != 0) - return; // Encore utilisé - - // Libération du module - - // Libération des dépendances - NzCore::Uninitialize(); - - NazaraNotice("Uninitialized: Noise module"); -} - -unsigned int NzNoise::s_moduleReferenceCouter = 0; diff --git a/src/Nazara/Noise/NoiseBase.cpp b/src/Nazara/Noise/NoiseBase.cpp index 03391cfa0..bd8564625 100644 --- a/src/Nazara/Noise/NoiseBase.cpp +++ b/src/Nazara/Noise/NoiseBase.cpp @@ -7,7 +7,7 @@ #include #include -NzNoiseBase::NzNoiseBase(int seed) +NzNoiseBase::NzNoiseBase(unsigned int seed) { Ua = 16807; Uc = 0; @@ -22,13 +22,13 @@ NzNoiseBase::NzNoiseBase(int seed) } -void NzNoiseBase::SetNewSeed(int seed) +void NzNoiseBase::SetNewSeed(unsigned int seed) { Uprevious = seed; UcurrentSeed = seed; } -int NzNoiseBase::GetUniformRandomValue() +unsigned int NzNoiseBase::GetUniformRandomValue() { Ulast = Ua*Uprevious + Uc%Um; Uprevious = Ulast; @@ -40,11 +40,11 @@ void NzNoiseBase::ShufflePermutationTable() int xchanger; unsigned int ncase; - for(int i(0) ; i < 256 ; i++) + for(unsigned int i(0) ; i < 256 ; i++) perm[i] = i; - for(int j(0) ; j < 20 ; ++j) - for (int i(0); i < 256 ; ++i) + for(unsigned int j(0) ; j < 20 ; ++j) + for (unsigned int i(0); i < 256 ; ++i) { ncase = this->GetUniformRandomValue() & 255; xchanger = perm[i]; @@ -52,7 +52,7 @@ void NzNoiseBase::ShufflePermutationTable() perm[ncase] = xchanger; } - for(int i(256) ; i < 512; ++i) + for(unsigned int i(256) ; i < 512; ++i) perm[i] = perm[i & 255]; } @@ -74,5 +74,3 @@ int NzNoiseBase::JenkinsHash(int a, int b, int c) c = c-a; c = c - b; c = c^(static_cast(b) >> 15); return c; } - -#include diff --git a/src/Nazara/Noise/Perlin2D.cpp b/src/Nazara/Noise/Perlin2D.cpp index 9ec67fbc7..bc68f4331 100644 --- a/src/Nazara/Noise/Perlin2D.cpp +++ b/src/Nazara/Noise/Perlin2D.cpp @@ -17,7 +17,7 @@ NzPerlin2D::NzPerlin2D() gradient2[i][j] = grad2Temp[i][j]; } -NzPerlin2D::NzPerlin2D(int seed) : NzPerlin2D() +NzPerlin2D::NzPerlin2D(unsigned int seed) : NzPerlin2D() { this->SetNewSeed(seed); this->ShufflePermutationTable(); diff --git a/src/Nazara/Noise/Perlin3D.cpp b/src/Nazara/Noise/Perlin3D.cpp index aa79e6d1d..49619a91a 100644 --- a/src/Nazara/Noise/Perlin3D.cpp +++ b/src/Nazara/Noise/Perlin3D.cpp @@ -21,7 +21,7 @@ NzPerlin3D::NzPerlin3D() gradient3[i][j] = grad3Temp[i][j]; } -NzPerlin3D::NzPerlin3D(int seed) : NzPerlin3D() +NzPerlin3D::NzPerlin3D(unsigned int seed) : NzPerlin3D() { this->SetNewSeed(seed); this->ShufflePermutationTable(); diff --git a/src/Nazara/Noise/Perlin4D.cpp b/src/Nazara/Noise/Perlin4D.cpp index 69bf03f5b..ef075691c 100644 --- a/src/Nazara/Noise/Perlin4D.cpp +++ b/src/Nazara/Noise/Perlin4D.cpp @@ -26,7 +26,7 @@ NzPerlin4D::NzPerlin4D() gradient4[i][j] = grad4Temp[i][j]; } -NzPerlin4D::NzPerlin4D(int seed) : NzPerlin4D() +NzPerlin4D::NzPerlin4D(unsigned int seed) : NzPerlin4D() { this->SetNewSeed(seed); this->ShufflePermutationTable(); diff --git a/src/Nazara/Noise/Simplex2D.cpp b/src/Nazara/Noise/Simplex2D.cpp index 392f44986..9cc577d0d 100644 --- a/src/Nazara/Noise/Simplex2D.cpp +++ b/src/Nazara/Noise/Simplex2D.cpp @@ -20,7 +20,7 @@ NzSimplex2D::NzSimplex2D() UnskewCoeff2D = (3.0-sqrt(3.0))/6.; } -NzSimplex2D::NzSimplex2D(int seed) : NzSimplex2D() +NzSimplex2D::NzSimplex2D(unsigned int seed) : NzSimplex2D() { this->SetNewSeed(seed); this->ShufflePermutationTable(); diff --git a/src/Nazara/Noise/Simplex3D.cpp b/src/Nazara/Noise/Simplex3D.cpp index 7436add6d..4669f9ca8 100644 --- a/src/Nazara/Noise/Simplex3D.cpp +++ b/src/Nazara/Noise/Simplex3D.cpp @@ -21,7 +21,7 @@ NzSimplex3D::NzSimplex3D() gradient3[i][j] = grad3Temp[i][j]; } -NzSimplex3D::NzSimplex3D(int seed) : NzSimplex3D() +NzSimplex3D::NzSimplex3D(unsigned int seed) : NzSimplex3D() { this->SetNewSeed(seed); this->ShufflePermutationTable(); diff --git a/src/Nazara/Noise/Simplex4D.cpp b/src/Nazara/Noise/Simplex4D.cpp index 99d7dd1ed..10940036f 100644 --- a/src/Nazara/Noise/Simplex4D.cpp +++ b/src/Nazara/Noise/Simplex4D.cpp @@ -45,7 +45,7 @@ NzSimplex4D::NzSimplex4D() gradient4[i][j] = grad4Temp[i][j]; } -NzSimplex4D::NzSimplex4D(int seed) : NzSimplex4D() +NzSimplex4D::NzSimplex4D(unsigned int seed) : NzSimplex4D() { this->SetNewSeed(seed); this->ShufflePermutationTable();