TorqueGameEngines/Torque3D
1
0
Fork 0
mirror of https://github.com/TorqueGameEngines/Torque3D.git synced 2026-07-11 06:34:36 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

Revert "Updated SDL, Bullet and OpenAL soft libs"

Browse source 
This reverts commit 370161cfb1.
This commit is contained in:
AzaezelX 2019-07-08 09:49:44 -05:00
parent 63be684474
commit bc77ff0833
1102 changed files with 62741 additions and 204988 deletions
Download patch file Download diff file Expand all files Collapse all files

55
Engine/lib/bullet/src/Bullet3Serialize/Bullet2FileLoader/CMakeLists.txt
View file

@ -1,55 +0,0 @@
INCLUDE_DIRECTORIES(
${BULLET_PHYSICS_SOURCE_DIR}/src
)
SET(Bullet2FileLoader_SRCS
b3BulletFile.cpp
b3Chunk.cpp
b3DNA.cpp
b3File.cpp
b3Serializer.cpp
)
SET(Bullet2FileLoader_HDRS
b3BulletFile.h
b3Chunk.h
b3Common.h
b3Defines.h
b3DNA.h
b3File.h
b3Serializer.h
autogenerated/bullet2.h
)
ADD_LIBRARY(Bullet2FileLoader ${Bullet2FileLoader_SRCS} ${Bullet2FileLoader_HDRS})
if (BUILD_SHARED_LIBS)
target_link_libraries(Bullet2FileLoader Bullet3Common)
endif ()
SET_TARGET_PROPERTIES(Bullet2FileLoader PROPERTIES VERSION ${BULLET_VERSION})
SET_TARGET_PROPERTIES(Bullet2FileLoader PROPERTIES SOVERSION ${BULLET_VERSION})
IF (INSTALL_LIBS)
IF (NOT INTERNAL_CREATE_DISTRIBUTABLE_MSVC_PROJECTFILES)
#FILES_MATCHING requires CMake 2.6
IF (${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} GREATER 2.5)
IF (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
INSTALL(TARGETS Bullet2FileLoader DESTINATION .)
ELSE (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
INSTALL(TARGETS Bullet2FileLoader
RUNTIME DESTINATION bin
LIBRARY DESTINATION lib${LIB_SUFFIX}
ARCHIVE DESTINATION lib${LIB_SUFFIX})
INSTALL(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
DESTINATION ${INCLUDE_INSTALL_DIR} FILES_MATCHING PATTERN "*.h" PATTERN
".svn" EXCLUDE PATTERN "CMakeFiles" EXCLUDE)
ENDIF (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
ENDIF (${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} GREATER 2.5)
IF (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
SET_TARGET_PROPERTIES(Bullet2FileLoader PROPERTIES FRAMEWORK true)
SET_TARGET_PROPERTIES(Bullet2FileLoader PROPERTIES PUBLIC_HEADER "${Bullet2FileLoader_HDRS}")
ENDIF (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
ENDIF (NOT INTERNAL_CREATE_DISTRIBUTABLE_MSVC_PROJECTFILES)
ENDIF (INSTALL_LIBS)

987
Engine/lib/bullet/src/Bullet3Serialize/Bullet2FileLoader/autogenerated/bullet2.h
View file

@ -1,987 +0,0 @@
/* Copyright (C) 2011 Erwin Coumans & Charlie C
*
* 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.
*/
// Auto generated from Bullet/Extras/HeaderGenerator/bulletGenerate.py
#ifndef __BULLET2_H__
#define __BULLET2_H__
namespace Bullet3SerializeBullet2
{
// put an empty struct in the case
typedef struct bInvalidHandle
{
int unused;
} bInvalidHandle;
class PointerArray;
class b3PhysicsSystem;
class ListBase;
class b3Vector3FloatData;
class b3Vector3DoubleData;
class b3Matrix3x3FloatData;
class b3Matrix3x3DoubleData;
class b3TransformFloatData;
class b3TransformDoubleData;
class b3BvhSubtreeInfoData;
class b3OptimizedBvhNodeFloatData;
class b3OptimizedBvhNodeDoubleData;
class b3QuantizedBvhNodeData;
class b3QuantizedBvhFloatData;
class b3QuantizedBvhDoubleData;
class b3CollisionShapeData;
class b3StaticPlaneShapeData;
class b3ConvexInternalShapeData;
class b3PositionAndRadius;
class b3MultiSphereShapeData;
class b3IntIndexData;
class b3ShortIntIndexData;
class b3ShortIntIndexTripletData;
class b3CharIndexTripletData;
class b3MeshPartData;
class b3StridingMeshInterfaceData;
class b3TriangleMeshShapeData;
class b3ScaledTriangleMeshShapeData;
class b3CompoundShapeChildData;
class b3CompoundShapeData;
class b3CylinderShapeData;
class b3CapsuleShapeData;
class b3TriangleInfoData;
class b3TriangleInfoMapData;
class b3GImpactMeshShapeData;
class b3ConvexHullShapeData;
class b3CollisionObjectDoubleData;
class b3CollisionObjectFloatData;
class b3DynamicsWorldDoubleData;
class b3DynamicsWorldFloatData;
class b3RigidBodyFloatData;
class b3RigidBodyDoubleData;
class b3ConstraintInfo1;
class b3TypedConstraintData;
class b3Point2PointConstraintFloatData;
class b3Point2PointConstraintDoubleData;
class b3HingeConstraintDoubleData;
class b3HingeConstraintFloatData;
class b3ConeTwistConstraintData;
class b3Generic6DofConstraintData;
class b3Generic6DofSpringConstraintData;
class b3SliderConstraintData;
class b3ContactSolverInfoDoubleData;
class b3ContactSolverInfoFloatData;
class SoftBodyMaterialData;
class SoftBodyNodeData;
class SoftBodyLinkData;
class SoftBodyFaceData;
class SoftBodyTetraData;
class SoftRigidAnchorData;
class SoftBodyConfigData;
class SoftBodyPoseData;
class SoftBodyClusterData;
class b3SoftBodyJointData;
class b3SoftBodyFloatData;
// -------------------------------------------------- //
class PointerArray
{
public:
int m_size;
int m_capacity;
void *m_data;
};
// -------------------------------------------------- //
class b3PhysicsSystem
{
public:
PointerArray m_collisionShapes;
PointerArray m_collisionObjects;
PointerArray m_constraints;
};
// -------------------------------------------------- //
class ListBase
{
public:
void *first;
void *last;
};
// -------------------------------------------------- //
class b3Vector3FloatData
{
public:
float m_floats[4];
};
// -------------------------------------------------- //
class b3Vector3DoubleData
{
public:
double m_floats[4];
};
// -------------------------------------------------- //
class b3Matrix3x3FloatData
{
public:
b3Vector3FloatData m_el[3];
};
// -------------------------------------------------- //
class b3Matrix3x3DoubleData
{
public:
b3Vector3DoubleData m_el[3];
};
// -------------------------------------------------- //
class b3TransformFloatData
{
public:
b3Matrix3x3FloatData m_basis;
b3Vector3FloatData m_origin;
};
// -------------------------------------------------- //
class b3TransformDoubleData
{
public:
b3Matrix3x3DoubleData m_basis;
b3Vector3DoubleData m_origin;
};
// -------------------------------------------------- //
class b3BvhSubtreeInfoData
{
public:
int m_rootNodeIndex;
int m_subtreeSize;
short m_quantizedAabbMin[3];
short m_quantizedAabbMax[3];
};
// -------------------------------------------------- //
class b3OptimizedBvhNodeFloatData
{
public:
b3Vector3FloatData m_aabbMinOrg;
b3Vector3FloatData m_aabbMaxOrg;
int m_escapeIndex;
int m_subPart;
int m_triangleIndex;
char m_pad[4];
};
// -------------------------------------------------- //
class b3OptimizedBvhNodeDoubleData
{
public:
b3Vector3DoubleData m_aabbMinOrg;
b3Vector3DoubleData m_aabbMaxOrg;
int m_escapeIndex;
int m_subPart;
int m_triangleIndex;
char m_pad[4];
};
// -------------------------------------------------- //
class b3QuantizedBvhNodeData
{
public:
short m_quantizedAabbMin[3];
short m_quantizedAabbMax[3];
int m_escapeIndexOrTriangleIndex;
};
// -------------------------------------------------- //
class b3QuantizedBvhFloatData
{
public:
b3Vector3FloatData m_bvhAabbMin;
b3Vector3FloatData m_bvhAabbMax;
b3Vector3FloatData m_bvhQuantization;
int m_curNodeIndex;
int m_useQuantization;
int m_numContiguousLeafNodes;
int m_numQuantizedContiguousNodes;
b3OptimizedBvhNodeFloatData *m_contiguousNodesPtr;
b3QuantizedBvhNodeData *m_quantizedContiguousNodesPtr;
b3BvhSubtreeInfoData *m_subTreeInfoPtr;
int m_traversalMode;
int m_numSubtreeHeaders;
};
// -------------------------------------------------- //
class b3QuantizedBvhDoubleData
{
public:
b3Vector3DoubleData m_bvhAabbMin;
b3Vector3DoubleData m_bvhAabbMax;
b3Vector3DoubleData m_bvhQuantization;
int m_curNodeIndex;
int m_useQuantization;
int m_numContiguousLeafNodes;
int m_numQuantizedContiguousNodes;
b3OptimizedBvhNodeDoubleData *m_contiguousNodesPtr;
b3QuantizedBvhNodeData *m_quantizedContiguousNodesPtr;
int m_traversalMode;
int m_numSubtreeHeaders;
b3BvhSubtreeInfoData *m_subTreeInfoPtr;
};
// -------------------------------------------------- //
class b3CollisionShapeData
{
public:
char *m_name;
int m_shapeType;
char m_padding[4];
};
// -------------------------------------------------- //
class b3StaticPlaneShapeData
{
public:
b3CollisionShapeData m_collisionShapeData;
b3Vector3FloatData m_localScaling;
b3Vector3FloatData m_planeNormal;
float m_planeConstant;
char m_pad[4];
};
// -------------------------------------------------- //
class b3ConvexInternalShapeData
{
public:
b3CollisionShapeData m_collisionShapeData;
b3Vector3FloatData m_localScaling;
b3Vector3FloatData m_implicitShapeDimensions;
float m_collisionMargin;
int m_padding;
};
// -------------------------------------------------- //
class b3PositionAndRadius
{
public:
b3Vector3FloatData m_pos;
float m_radius;
};
// -------------------------------------------------- //
class b3MultiSphereShapeData
{
public:
b3ConvexInternalShapeData m_convexInternalShapeData;
b3PositionAndRadius *m_localPositionArrayPtr;
int m_localPositionArraySize;
char m_padding[4];
};
// -------------------------------------------------- //
class b3IntIndexData
{
public:
int m_value;
};
// -------------------------------------------------- //
class b3ShortIntIndexData
{
public:
short m_value;
char m_pad[2];
};
// -------------------------------------------------- //
class b3ShortIntIndexTripletData
{
public:
short m_values[3];
char m_pad[2];
};
// -------------------------------------------------- //
class b3CharIndexTripletData
{
public:
char m_values[3];
char m_pad;
};
// -------------------------------------------------- //
class b3MeshPartData
{
public:
b3Vector3FloatData *m_vertices3f;
b3Vector3DoubleData *m_vertices3d;
b3IntIndexData *m_indices32;
b3ShortIntIndexTripletData *m_3indices16;
b3CharIndexTripletData *m_3indices8;
b3ShortIntIndexData *m_indices16;
int m_numTriangles;
int m_numVertices;
};
// -------------------------------------------------- //
class b3StridingMeshInterfaceData
{
public:
b3MeshPartData *m_meshPartsPtr;
b3Vector3FloatData m_scaling;
int m_numMeshParts;
char m_padding[4];
};
// -------------------------------------------------- //
class b3TriangleMeshShapeData
{
public:
b3CollisionShapeData m_collisionShapeData;
b3StridingMeshInterfaceData m_meshInterface;
b3QuantizedBvhFloatData *m_quantizedFloatBvh;
b3QuantizedBvhDoubleData *m_quantizedDoubleBvh;
b3TriangleInfoMapData *m_triangleInfoMap;
float m_collisionMargin;
char m_pad3[4];
};
// -------------------------------------------------- //
class b3ScaledTriangleMeshShapeData
{
public:
b3TriangleMeshShapeData m_trimeshShapeData;
b3Vector3FloatData m_localScaling;
};
// -------------------------------------------------- //
class b3CompoundShapeChildData
{
public:
b3TransformFloatData m_transform;
b3CollisionShapeData *m_childShape;
int m_childShapeType;
float m_childMargin;
};
// -------------------------------------------------- //
class b3CompoundShapeData
{
public:
b3CollisionShapeData m_collisionShapeData;
b3CompoundShapeChildData *m_childShapePtr;
int m_numChildShapes;
float m_collisionMargin;
};
// -------------------------------------------------- //
class b3CylinderShapeData
{
public:
b3ConvexInternalShapeData m_convexInternalShapeData;
int m_upAxis;
char m_padding[4];
};
// -------------------------------------------------- //
class b3CapsuleShapeData
{
public:
b3ConvexInternalShapeData m_convexInternalShapeData;
int m_upAxis;
char m_padding[4];
};
// -------------------------------------------------- //
class b3TriangleInfoData
{
public:
int m_flags;
float m_edgeV0V1Angle;
float m_edgeV1V2Angle;
float m_edgeV2V0Angle;
};
// -------------------------------------------------- //
class b3TriangleInfoMapData
{
public:
int *m_hashTablePtr;
int *m_nextPtr;
b3TriangleInfoData *m_valueArrayPtr;
int *m_keyArrayPtr;
float m_convexEpsilon;
float m_planarEpsilon;
float m_equalVertexThreshold;
float m_edgeDistanceThreshold;
float m_zeroAreaThreshold;
int m_nextSize;
int m_hashTableSize;
int m_numValues;
int m_numKeys;
char m_padding[4];
};
// -------------------------------------------------- //
class b3GImpactMeshShapeData
{
public:
b3CollisionShapeData m_collisionShapeData;
b3StridingMeshInterfaceData m_meshInterface;
b3Vector3FloatData m_localScaling;
float m_collisionMargin;
int m_gimpactSubType;
};
// -------------------------------------------------- //
class b3ConvexHullShapeData
{
public:
b3ConvexInternalShapeData m_convexInternalShapeData;
b3Vector3FloatData *m_unscaledPointsFloatPtr;
b3Vector3DoubleData *m_unscaledPointsDoublePtr;
int m_numUnscaledPoints;
char m_padding3[4];
};
// -------------------------------------------------- //
class b3CollisionObjectDoubleData
{
public:
void *m_broadphaseHandle;
void *m_collisionShape;
b3CollisionShapeData *m_rootCollisionShape;
char *m_name;
b3TransformDoubleData m_worldTransform;
b3TransformDoubleData m_interpolationWorldTransform;
b3Vector3DoubleData m_interpolationLinearVelocity;
b3Vector3DoubleData m_interpolationAngularVelocity;
b3Vector3DoubleData m_anisotropicFriction;
double m_contactProcessingThreshold;
double m_deactivationTime;
double m_friction;
double m_rollingFriction;
double m_restitution;
double m_hitFraction;
double m_ccdSweptSphereRadius;
double m_ccdMotionThreshold;
int m_hasAnisotropicFriction;
int m_collisionFlags;
int m_islandTag1;
int m_companionId;
int m_activationState1;
int m_internalType;
int m_checkCollideWith;
char m_padding[4];
};
// -------------------------------------------------- //
class b3CollisionObjectFloatData
{
public:
void *m_broadphaseHandle;
void *m_collisionShape;
b3CollisionShapeData *m_rootCollisionShape;
char *m_name;
b3TransformFloatData m_worldTransform;
b3TransformFloatData m_interpolationWorldTransform;
b3Vector3FloatData m_interpolationLinearVelocity;
b3Vector3FloatData m_interpolationAngularVelocity;
b3Vector3FloatData m_anisotropicFriction;
float m_contactProcessingThreshold;
float m_deactivationTime;
float m_friction;
float m_rollingFriction;
float m_restitution;
float m_hitFraction;
float m_ccdSweptSphereRadius;
float m_ccdMotionThreshold;
int m_hasAnisotropicFriction;
int m_collisionFlags;
int m_islandTag1;
int m_companionId;
int m_activationState1;
int m_internalType;
int m_checkCollideWith;
char m_padding[4];
};
// -------------------------------------------------- //
class b3RigidBodyFloatData
{
public:
b3CollisionObjectFloatData m_collisionObjectData;
b3Matrix3x3FloatData m_invInertiaTensorWorld;
b3Vector3FloatData m_linearVelocity;
b3Vector3FloatData m_angularVelocity;
b3Vector3FloatData m_angularFactor;
b3Vector3FloatData m_linearFactor;
b3Vector3FloatData m_gravity;
b3Vector3FloatData m_gravity_acceleration;
b3Vector3FloatData m_invInertiaLocal;
b3Vector3FloatData m_totalForce;
b3Vector3FloatData m_totalTorque;
float m_inverseMass;
float m_linearDamping;
float m_angularDamping;
float m_additionalDampingFactor;
float m_additionalLinearDampingThresholdSqr;
float m_additionalAngularDampingThresholdSqr;
float m_additionalAngularDampingFactor;
float m_linearSleepingThreshold;
float m_angularSleepingThreshold;
int m_additionalDamping;
};
// -------------------------------------------------- //
class b3RigidBodyDoubleData
{
public:
b3CollisionObjectDoubleData m_collisionObjectData;
b3Matrix3x3DoubleData m_invInertiaTensorWorld;
b3Vector3DoubleData m_linearVelocity;
b3Vector3DoubleData m_angularVelocity;
b3Vector3DoubleData m_angularFactor;
b3Vector3DoubleData m_linearFactor;
b3Vector3DoubleData m_gravity;
b3Vector3DoubleData m_gravity_acceleration;
b3Vector3DoubleData m_invInertiaLocal;
b3Vector3DoubleData m_totalForce;
b3Vector3DoubleData m_totalTorque;
double m_inverseMass;
double m_linearDamping;
double m_angularDamping;
double m_additionalDampingFactor;
double m_additionalLinearDampingThresholdSqr;
double m_additionalAngularDampingThresholdSqr;
double m_additionalAngularDampingFactor;
double m_linearSleepingThreshold;
double m_angularSleepingThreshold;
int m_additionalDamping;
char m_padding[4];
};
// -------------------------------------------------- //
class b3ConstraintInfo1
{
public:
int m_numConstraintRows;
int nub;
};
// -------------------------------------------------- //
class b3TypedConstraintData
{
public:
bInvalidHandle *m_rbA;
bInvalidHandle *m_rbB;
char *m_name;
int m_objectType;
int m_userConstraintType;
int m_userConstraintId;
int m_needsFeedback;
float m_appliedImpulse;
float m_dbgDrawSize;
int m_disableCollisionsBetweenLinkedBodies;
int m_overrideNumSolverIterations;
float m_breakingImpulseThreshold;
int m_isEnabled;
};
// -------------------------------------------------- //
class b3Point2PointConstraintFloatData
{
public:
b3TypedConstraintData m_typeConstraintData;
b3Vector3FloatData m_pivotInA;
b3Vector3FloatData m_pivotInB;
};
// -------------------------------------------------- //
class b3Point2PointConstraintDoubleData
{
public:
b3TypedConstraintData m_typeConstraintData;
b3Vector3DoubleData m_pivotInA;
b3Vector3DoubleData m_pivotInB;
};
// -------------------------------------------------- //
class b3HingeConstraintDoubleData
{
public:
b3TypedConstraintData m_typeConstraintData;
b3TransformDoubleData m_rbAFrame;
b3TransformDoubleData m_rbBFrame;
int m_useReferenceFrameA;
int m_angularOnly;
int m_enableAngularMotor;
float m_motorTargetVelocity;
float m_maxMotorImpulse;
float m_lowerLimit;
float m_upperLimit;
float m_limitSoftness;
float m_biasFactor;
float m_relaxationFactor;
};
// -------------------------------------------------- //
class b3HingeConstraintFloatData
{
public:
b3TypedConstraintData m_typeConstraintData;
b3TransformFloatData m_rbAFrame;
b3TransformFloatData m_rbBFrame;
int m_useReferenceFrameA;
int m_angularOnly;
int m_enableAngularMotor;
float m_motorTargetVelocity;
float m_maxMotorImpulse;
float m_lowerLimit;
float m_upperLimit;
float m_limitSoftness;
float m_biasFactor;
float m_relaxationFactor;
};
// -------------------------------------------------- //
class b3ConeTwistConstraintData
{
public:
b3TypedConstraintData m_typeConstraintData;
b3TransformFloatData m_rbAFrame;
b3TransformFloatData m_rbBFrame;
float m_swingSpan1;
float m_swingSpan2;
float m_twistSpan;
float m_limitSoftness;
float m_biasFactor;
float m_relaxationFactor;
float m_damping;
char m_pad[4];
};
// -------------------------------------------------- //
class b3Generic6DofConstraintData
{
public:
b3TypedConstraintData m_typeConstraintData;
b3TransformFloatData m_rbAFrame;
b3TransformFloatData m_rbBFrame;
b3Vector3FloatData m_linearUpperLimit;
b3Vector3FloatData m_linearLowerLimit;
b3Vector3FloatData m_angularUpperLimit;
b3Vector3FloatData m_angularLowerLimit;
int m_useLinearReferenceFrameA;
int m_useOffsetForConstraintFrame;
};
// -------------------------------------------------- //
class b3Generic6DofSpringConstraintData
{
public:
b3Generic6DofConstraintData m_6dofData;
int m_springEnabled[6];
float m_equilibriumPoint[6];
float m_springStiffness[6];
float m_springDamping[6];
};
// -------------------------------------------------- //
class b3SliderConstraintData
{
public:
b3TypedConstraintData m_typeConstraintData;
b3TransformFloatData m_rbAFrame;
b3TransformFloatData m_rbBFrame;
float m_linearUpperLimit;
float m_linearLowerLimit;
float m_angularUpperLimit;
float m_angularLowerLimit;
int m_useLinearReferenceFrameA;
int m_useOffsetForConstraintFrame;
};
// -------------------------------------------------- //
class b3ContactSolverInfoDoubleData
{
public:
double m_tau;
double m_damping;
double m_friction;
double m_timeStep;
double m_restitution;
double m_maxErrorReduction;
double m_sor;
double m_erp;
double m_erp2;
double m_globalCfm;
double m_splitImpulsePenetrationThreshold;
double m_splitImpulseTurnErp;
double m_linearSlop;
double m_warmstartingFactor;
double m_maxGyroscopicForce;
double m_singleAxisRollingFrictionThreshold;
int m_numIterations;
int m_solverMode;
int m_restingContactRestitutionThreshold;
int m_minimumSolverBatchSize;
int m_splitImpulse;
char m_padding[4];
};
// -------------------------------------------------- //
class b3ContactSolverInfoFloatData
{
public:
float m_tau;
float m_damping;
float m_friction;
float m_timeStep;
float m_restitution;
float m_maxErrorReduction;
float m_sor;
float m_erp;
float m_erp2;
float m_globalCfm;
float m_splitImpulsePenetrationThreshold;
float m_splitImpulseTurnErp;
float m_linearSlop;
float m_warmstartingFactor;
float m_maxGyroscopicForce;
float m_singleAxisRollingFrictionThreshold;
int m_numIterations;
int m_solverMode;
int m_restingContactRestitutionThreshold;
int m_minimumSolverBatchSize;
int m_splitImpulse;
char m_padding[4];
};
// -------------------------------------------------- //
class b3DynamicsWorldDoubleData
{
public:
b3ContactSolverInfoDoubleData m_solverInfo;
b3Vector3DoubleData m_gravity;
};
// -------------------------------------------------- //
class b3DynamicsWorldFloatData
{
public:
b3ContactSolverInfoFloatData m_solverInfo;
b3Vector3FloatData m_gravity;
};
// -------------------------------------------------- //
class SoftBodyMaterialData
{
public:
float m_linearStiffness;
float m_angularStiffness;
float m_volumeStiffness;
int m_flags;
};
// -------------------------------------------------- //
class SoftBodyNodeData
{
public:
SoftBodyMaterialData *m_material;
b3Vector3FloatData m_position;
b3Vector3FloatData m_previousPosition;
b3Vector3FloatData m_velocity;
b3Vector3FloatData m_accumulatedForce;
b3Vector3FloatData m_normal;
float m_inverseMass;
float m_area;
int m_attach;
int m_pad;
};
// -------------------------------------------------- //
class SoftBodyLinkData
{
public:
SoftBodyMaterialData *m_material;
int m_nodeIndices[2];
float m_restLength;
int m_bbending;
};
// -------------------------------------------------- //
class SoftBodyFaceData
{
public:
b3Vector3FloatData m_normal;
SoftBodyMaterialData *m_material;
int m_nodeIndices[3];
float m_restArea;
};
// -------------------------------------------------- //
class SoftBodyTetraData
{
public:
b3Vector3FloatData m_c0[4];
SoftBodyMaterialData *m_material;
int m_nodeIndices[4];
float m_restVolume;
float m_c1;
float m_c2;
int m_pad;
};
// -------------------------------------------------- //
class SoftRigidAnchorData
{
public:
b3Matrix3x3FloatData m_c0;
b3Vector3FloatData m_c1;
b3Vector3FloatData m_localFrame;
bInvalidHandle *m_rigidBody;
int m_nodeIndex;
float m_c2;
};
// -------------------------------------------------- //
class SoftBodyConfigData
{
public:
int m_aeroModel;
float m_baumgarte;
float m_damping;
float m_drag;
float m_lift;
float m_pressure;
float m_volume;
float m_dynamicFriction;
float m_poseMatch;
float m_rigidContactHardness;
float m_kineticContactHardness;
float m_softContactHardness;
float m_anchorHardness;
float m_softRigidClusterHardness;
float m_softKineticClusterHardness;
float m_softSoftClusterHardness;
float m_softRigidClusterImpulseSplit;
float m_softKineticClusterImpulseSplit;
float m_softSoftClusterImpulseSplit;
float m_maxVolume;
float m_timeScale;
int m_velocityIterations;
int m_positionIterations;
int m_driftIterations;
int m_clusterIterations;
int m_collisionFlags;
};
// -------------------------------------------------- //
class SoftBodyPoseData
{
public:
b3Matrix3x3FloatData m_rot;
b3Matrix3x3FloatData m_scale;
b3Matrix3x3FloatData m_aqq;
b3Vector3FloatData m_com;
b3Vector3FloatData *m_positions;
float *m_weights;
int m_numPositions;
int m_numWeigts;
int m_bvolume;
int m_bframe;
float m_restVolume;
int m_pad;
};
// -------------------------------------------------- //
class SoftBodyClusterData
{
public:
b3TransformFloatData m_framexform;
b3Matrix3x3FloatData m_locii;
b3Matrix3x3FloatData m_invwi;
b3Vector3FloatData m_com;
b3Vector3FloatData m_vimpulses[2];
b3Vector3FloatData m_dimpulses[2];
b3Vector3FloatData m_lv;
b3Vector3FloatData m_av;
b3Vector3FloatData *m_framerefs;
int *m_nodeIndices;
float *m_masses;
int m_numFrameRefs;
int m_numNodes;
int m_numMasses;
float m_idmass;
float m_imass;
int m_nvimpulses;
int m_ndimpulses;
float m_ndamping;
float m_ldamping;
float m_adamping;
float m_matching;
float m_maxSelfCollisionImpulse;
float m_selfCollisionImpulseFactor;
int m_containsAnchor;
int m_collide;
int m_clusterIndex;
};
// -------------------------------------------------- //
class b3SoftBodyJointData
{
public:
void *m_bodyA;
void *m_bodyB;
b3Vector3FloatData m_refs[2];
float m_cfm;
float m_erp;
float m_split;
int m_delete;
b3Vector3FloatData m_relPosition[2];
int m_bodyAtype;
int m_bodyBtype;
int m_jointType;
int m_pad;
};
// -------------------------------------------------- //
class b3SoftBodyFloatData
{
public:
b3CollisionObjectFloatData m_collisionObjectData;
SoftBodyPoseData *m_pose;
SoftBodyMaterialData **m_materials;
SoftBodyNodeData *m_nodes;
SoftBodyLinkData *m_links;
SoftBodyFaceData *m_faces;
SoftBodyTetraData *m_tetrahedra;
SoftRigidAnchorData *m_anchors;
SoftBodyClusterData *m_clusters;
b3SoftBodyJointData *m_joints;
int m_numMaterials;
int m_numNodes;
int m_numLinks;
int m_numFaces;
int m_numTetrahedra;
int m_numAnchors;
int m_numClusters;
int m_numJoints;
SoftBodyConfigData m_config;
};
} // namespace Bullet3SerializeBullet2
#endif //__BULLET2_H__

400
Engine/lib/bullet/src/Bullet3Serialize/Bullet2FileLoader/b3BulletFile.cpp
View file

@ -1,400 +0,0 @@
/*
bParse
Copyright (c) 2006-2010 Erwin Coumans http://gamekit.googlecode.com
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.
*/
#include "b3BulletFile.h"
#include "b3Defines.h"
#include "b3DNA.h"
#if !defined(__CELLOS_LV2__) && !defined(__MWERKS__)
#include <memory.h>
#endif
#include <string.h>
// 32 && 64 bit versions
#ifdef B3_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
#ifdef _WIN64
extern char b3s_bulletDNAstr64[];
extern int b3s_bulletDNAlen64;
#else
extern char b3s_bulletDNAstr[];
extern int b3s_bulletDNAlen;
#endif //_WIN64
#else //B3_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
extern char b3s_bulletDNAstr64[];
extern int b3s_bulletDNAlen64;
extern char b3s_bulletDNAstr[];
extern int b3s_bulletDNAlen;
#endif //B3_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
using namespace bParse;
b3BulletFile::b3BulletFile()
: bFile("", "BULLET ")
{
mMemoryDNA = new bDNA(); //this memory gets released in the bFile::~bFile destructor,@todo not consistent with the rule 'who allocates it, has to deallocate it"
m_DnaCopy = 0;
#ifdef B3_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
#ifdef _WIN64
m_DnaCopy = (char*)b3AlignedAlloc(b3s_bulletDNAlen64, 16);
memcpy(m_DnaCopy, b3s_bulletDNAstr64, b3s_bulletDNAlen64);
mMemoryDNA->init(m_DnaCopy, b3s_bulletDNAlen64);
#else //_WIN64
m_DnaCopy = (char*)b3AlignedAlloc(b3s_bulletDNAlen, 16);
memcpy(m_DnaCopy, b3s_bulletDNAstr, b3s_bulletDNAlen);
mMemoryDNA->init(m_DnaCopy, b3s_bulletDNAlen);
#endif //_WIN64
#else //B3_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
if (VOID_IS_8)
{
m_DnaCopy = (char*)b3AlignedAlloc(b3s_bulletDNAlen64, 16);
memcpy(m_DnaCopy, b3s_bulletDNAstr64, b3s_bulletDNAlen64);
mMemoryDNA->init(m_DnaCopy, b3s_bulletDNAlen64);
}
else
{
m_DnaCopy = (char*)b3AlignedAlloc(b3s_bulletDNAlen, 16);
memcpy(m_DnaCopy, b3s_bulletDNAstr, b3s_bulletDNAlen);
mMemoryDNA->init(m_DnaCopy, b3s_bulletDNAlen);
}
#endif //B3_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
}
b3BulletFile::b3BulletFile(const char* fileName)
: bFile(fileName, "BULLET ")
{
m_DnaCopy = 0;
}
b3BulletFile::b3BulletFile(char* memoryBuffer, int len)
: bFile(memoryBuffer, len, "BULLET ")
{
m_DnaCopy = 0;
}
b3BulletFile::~b3BulletFile()
{
if (m_DnaCopy)
b3AlignedFree(m_DnaCopy);
while (m_dataBlocks.size())
{
char* dataBlock = m_dataBlocks[m_dataBlocks.size() - 1];
delete[] dataBlock;
m_dataBlocks.pop_back();
}
}
// ----------------------------------------------------- //
void b3BulletFile::parseData()
{
// printf ("Building datablocks");
// printf ("Chunk size = %d",CHUNK_HEADER_LEN);
// printf ("File chunk size = %d",ChunkUtils::getOffset(mFlags));
const bool brokenDNA = (mFlags & FD_BROKEN_DNA) != 0;
//const bool swap = (mFlags&FD_ENDIAN_SWAP)!=0;
mDataStart = 12;
char* dataPtr = mFileBuffer + mDataStart;
bChunkInd dataChunk;
dataChunk.code = 0;
//dataPtr += ChunkUtils::getNextBlock(&dataChunk, dataPtr, mFlags);
int seek = getNextBlock(&dataChunk, dataPtr, mFlags);
if (mFlags & FD_ENDIAN_SWAP)
swapLen(dataPtr);
//dataPtr += ChunkUtils::getOffset(mFlags);
char* dataPtrHead = 0;
while (dataChunk.code != B3_DNA1)
{
if (!brokenDNA || (dataChunk.code != B3_QUANTIZED_BVH_CODE))
{
// one behind
if (dataChunk.code == B3_SDNA) break;
//if (dataChunk.code == DNA1) break;
// same as (BHEAD+DATA dependency)
dataPtrHead = dataPtr + ChunkUtils::getOffset(mFlags);
if (dataChunk.dna_nr >= 0)
{
char* id = readStruct(dataPtrHead, dataChunk);
// lookup maps
if (id)
{
m_chunkPtrPtrMap.insert(dataChunk.oldPtr, dataChunk);
mLibPointers.insert(dataChunk.oldPtr, (bStructHandle*)id);
m_chunks.push_back(dataChunk);
// block it
//bListBasePtr *listID = mMain->getListBasePtr(dataChunk.code);
//if (listID)
// listID->push_back((bStructHandle*)id);
}
if (dataChunk.code == B3_SOFTBODY_CODE)
{
m_softBodies.push_back((bStructHandle*)id);
}
if (dataChunk.code == B3_RIGIDBODY_CODE)
{
m_rigidBodies.push_back((bStructHandle*)id);
}
if (dataChunk.code == B3_DYNAMICSWORLD_CODE)
{
m_dynamicsWorldInfo.push_back((bStructHandle*)id);
}
if (dataChunk.code == B3_CONSTRAINT_CODE)
{
m_constraints.push_back((bStructHandle*)id);
}
if (dataChunk.code == B3_QUANTIZED_BVH_CODE)
{
m_bvhs.push_back((bStructHandle*)id);
}
if (dataChunk.code == B3_TRIANLGE_INFO_MAP)
{
m_triangleInfoMaps.push_back((bStructHandle*)id);
}
if (dataChunk.code == B3_COLLISIONOBJECT_CODE)
{
m_collisionObjects.push_back((bStructHandle*)id);
}
if (dataChunk.code == B3_SHAPE_CODE)
{
m_collisionShapes.push_back((bStructHandle*)id);
}
// if (dataChunk.code == GLOB)
// {
// m_glob = (bStructHandle*) id;
// }
}
else
{
//printf("unknown chunk\n");
mLibPointers.insert(dataChunk.oldPtr, (bStructHandle*)dataPtrHead);
}
}
else
{
printf("skipping B3_QUANTIZED_BVH_CODE due to broken DNA\n");
}
dataPtr += seek;
seek = getNextBlock(&dataChunk, dataPtr, mFlags);
if (mFlags & FD_ENDIAN_SWAP)
swapLen(dataPtr);
if (seek < 0)
break;
}
}
void b3BulletFile::addDataBlock(char* dataBlock)
{
m_dataBlocks.push_back(dataBlock);
}
void b3BulletFile::writeDNA(FILE* fp)
{
bChunkInd dataChunk;
dataChunk.code = B3_DNA1;
dataChunk.dna_nr = 0;
dataChunk.nr = 1;
#ifdef B3_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
if (VOID_IS_8)
{
#ifdef _WIN64
dataChunk.len = b3s_bulletDNAlen64;
dataChunk.oldPtr = b3s_bulletDNAstr64;
fwrite(&dataChunk, sizeof(bChunkInd), 1, fp);
fwrite(b3s_bulletDNAstr64, b3s_bulletDNAlen64, 1, fp);
#else
b3Assert(0);
#endif
}
else
{
#ifndef _WIN64
dataChunk.len = b3s_bulletDNAlen;
dataChunk.oldPtr = b3s_bulletDNAstr;
fwrite(&dataChunk, sizeof(bChunkInd), 1, fp);
fwrite(b3s_bulletDNAstr, b3s_bulletDNAlen, 1, fp);
#else //_WIN64
b3Assert(0);
#endif //_WIN64
}
#else //B3_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
if (VOID_IS_8)
{
dataChunk.len = b3s_bulletDNAlen64;
dataChunk.oldPtr = b3s_bulletDNAstr64;
fwrite(&dataChunk, sizeof(bChunkInd), 1, fp);
fwrite(b3s_bulletDNAstr64, b3s_bulletDNAlen64, 1, fp);
}
else
{
dataChunk.len = b3s_bulletDNAlen;
dataChunk.oldPtr = b3s_bulletDNAstr;
fwrite(&dataChunk, sizeof(bChunkInd), 1, fp);
fwrite(b3s_bulletDNAstr, b3s_bulletDNAlen, 1, fp);
}
#endif //B3_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
}
void b3BulletFile::parse(int verboseMode)
{
#ifdef B3_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
if (VOID_IS_8)
{
#ifdef _WIN64
if (m_DnaCopy)
delete m_DnaCopy;
m_DnaCopy = (char*)b3AlignedAlloc(b3s_bulletDNAlen64, 16);
memcpy(m_DnaCopy, b3s_bulletDNAstr64, b3s_bulletDNAlen64);
parseInternal(verboseMode, (char*)b3s_bulletDNAstr64, b3s_bulletDNAlen64);
#else
b3Assert(0);
#endif
}
else
{
#ifndef _WIN64
if (m_DnaCopy)
delete m_DnaCopy;
m_DnaCopy = (char*)b3AlignedAlloc(b3s_bulletDNAlen, 16);
memcpy(m_DnaCopy, b3s_bulletDNAstr, b3s_bulletDNAlen);
parseInternal(verboseMode, m_DnaCopy, b3s_bulletDNAlen);
#else
b3Assert(0);
#endif
}
#else //B3_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
if (VOID_IS_8)
{
if (m_DnaCopy)
delete m_DnaCopy;
m_DnaCopy = (char*)b3AlignedAlloc(b3s_bulletDNAlen64, 16);
memcpy(m_DnaCopy, b3s_bulletDNAstr64, b3s_bulletDNAlen64);
parseInternal(verboseMode, m_DnaCopy, b3s_bulletDNAlen64);
}
else
{
if (m_DnaCopy)
delete m_DnaCopy;
m_DnaCopy = (char*)b3AlignedAlloc(b3s_bulletDNAlen, 16);
memcpy(m_DnaCopy, b3s_bulletDNAstr, b3s_bulletDNAlen);
parseInternal(verboseMode, m_DnaCopy, b3s_bulletDNAlen);
}
#endif //B3_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
//the parsing will convert to cpu endian
mFlags &= ~FD_ENDIAN_SWAP;
int littleEndian = 1;
littleEndian = ((char*)&littleEndian)[0];
mFileBuffer[8] = littleEndian ? 'v' : 'V';
}
// experimental
int b3BulletFile::write(const char* fileName, bool fixupPointers)
{
FILE* fp = fopen(fileName, "wb");
if (fp)
{
char header[B3_SIZEOFBLENDERHEADER];
memcpy(header, m_headerString, 7);
int endian = 1;
endian = ((char*)&endian)[0];
if (endian)
{
header[7] = '_';
}
else
{
header[7] = '-';
}
if (VOID_IS_8)
{
header[8] = 'V';
}
else
{
header[8] = 'v';
}
header[9] = '2';
header[10] = '7';
header[11] = '5';
fwrite(header, B3_SIZEOFBLENDERHEADER, 1, fp);
writeChunks(fp, fixupPointers);
writeDNA(fp);
fclose(fp);
}
else
{
printf("Error: cannot open file %s for writing\n", fileName);
return 0;
}
return 1;
}
void b3BulletFile::addStruct(const char* structType, void* data, int len, void* oldPtr, int code)
{
bParse::bChunkInd dataChunk;
dataChunk.code = code;
dataChunk.nr = 1;
dataChunk.len = len;
dataChunk.dna_nr = mMemoryDNA->getReverseType(structType);
dataChunk.oldPtr = oldPtr;
///Perform structure size validation
short* structInfo = mMemoryDNA->getStruct(dataChunk.dna_nr);
int elemBytes;
elemBytes = mMemoryDNA->getLength(structInfo[0]);
// int elemBytes = mMemoryDNA->getElementSize(structInfo[0],structInfo[1]);
assert(len == elemBytes);
mLibPointers.insert(dataChunk.oldPtr, (bStructHandle*)data);
m_chunks.push_back(dataChunk);
}

74
Engine/lib/bullet/src/Bullet3Serialize/Bullet2FileLoader/b3BulletFile.h
View file

@ -1,74 +0,0 @@
/*
bParse
Copyright (c) 2006-2010 Charlie C & Erwin Coumans http://gamekit.googlecode.com
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 B3_BULLET_FILE_H
#define B3_BULLET_FILE_H
#include "b3File.h"
#include "Bullet3Common/b3AlignedObjectArray.h"
#include "b3Defines.h"
#include "Bullet3Serialize/Bullet2FileLoader/b3Serializer.h"
namespace bParse
{
// ----------------------------------------------------- //
class b3BulletFile : public bFile
{
protected:
char* m_DnaCopy;
public:
b3AlignedObjectArray<bStructHandle*> m_softBodies;
b3AlignedObjectArray<bStructHandle*> m_rigidBodies;
b3AlignedObjectArray<bStructHandle*> m_collisionObjects;
b3AlignedObjectArray<bStructHandle*> m_collisionShapes;
b3AlignedObjectArray<bStructHandle*> m_constraints;
b3AlignedObjectArray<bStructHandle*> m_bvhs;
b3AlignedObjectArray<bStructHandle*> m_triangleInfoMaps;
b3AlignedObjectArray<bStructHandle*> m_dynamicsWorldInfo;
b3AlignedObjectArray<char*> m_dataBlocks;
b3BulletFile();
b3BulletFile(const char* fileName);
b3BulletFile(char* memoryBuffer, int len);
virtual ~b3BulletFile();
virtual void addDataBlock(char* dataBlock);
// experimental
virtual int write(const char* fileName, bool fixupPointers = false);
virtual void parse(int verboseMode);
virtual void parseData();
virtual void writeDNA(FILE* fp);
void addStruct(const char* structType, void* data, int len, void* oldPtr, int code);
};
}; // namespace bParse
#endif //B3_BULLET_FILE_H

69
Engine/lib/bullet/src/Bullet3Serialize/Bullet2FileLoader/b3Chunk.cpp
View file

@ -1,69 +0,0 @@
/*
bParse
Copyright (c) 2006-2009 Charlie C & Erwin Coumans http://gamekit.googlecode.com
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.
*/
#include "b3Chunk.h"
#include "b3Defines.h"
#include "b3File.h"
#if !defined(__CELLOS_LV2__) && !defined(__MWERKS__)
#include <memory.h>
#endif
#include <string.h>
using namespace bParse;
// ----------------------------------------------------- //
short ChunkUtils::swapShort(short sht)
{
B3_SWITCH_SHORT(sht);
return sht;
}
// ----------------------------------------------------- //
int ChunkUtils::swapInt(int inte)
{
B3_SWITCH_INT(inte);
return inte;
}
// ----------------------------------------------------- //
b3Long64 ChunkUtils::swapLong64(b3Long64 lng)
{
B3_SWITCH_LONGINT(lng);
return lng;
}
// ----------------------------------------------------- //
int ChunkUtils::getOffset(int flags)
{
// if the file is saved in a
// different format, get the
// file's chunk size
int res = CHUNK_HEADER_LEN;
if (VOID_IS_8)
{
if (flags & FD_BITS_VARIES)
res = sizeof(bChunkPtr4);
}
else
{
if (flags & FD_BITS_VARIES)
res = sizeof(bChunkPtr8);
}
return res;
}
//eof

84
Engine/lib/bullet/src/Bullet3Serialize/Bullet2FileLoader/b3Chunk.h
View file

@ -1,84 +0,0 @@
/*
bParse
Copyright (c) 2006-2009 Charlie C & Erwin Coumans http://gamekit.googlecode.com
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 __BCHUNK_H__
#define __BCHUNK_H__
#if defined(_WIN32) && !defined(__MINGW32__)
#define b3Long64 __int64
#elif defined(__MINGW32__)
#include <stdint.h>
#define b3Long64 int64_t
#else
#define b3Long64 long long
#endif
namespace bParse
{
// ----------------------------------------------------- //
class bChunkPtr4
{
public:
bChunkPtr4() {}
int code;
int len;
union {
int m_uniqueInt;
};
int dna_nr;
int nr;
};
// ----------------------------------------------------- //
class bChunkPtr8
{
public:
bChunkPtr8() {}
int code, len;
union {
b3Long64 oldPrev;
int m_uniqueInts[2];
};
int dna_nr, nr;
};
// ----------------------------------------------------- //
class bChunkInd
{
public:
bChunkInd() {}
int code, len;
void *oldPtr;
int dna_nr, nr;
};
// ----------------------------------------------------- //
class ChunkUtils
{
public:
// file chunk offset
static int getOffset(int flags);
// endian utils
static short swapShort(short sht);
static int swapInt(int inte);
static b3Long64 swapLong64(b3Long64 lng);
};
const int CHUNK_HEADER_LEN = ((sizeof(bChunkInd)));
const bool VOID_IS_8 = ((sizeof(void *) == 8));
} // namespace bParse
#endif //__BCHUNK_H__

40
Engine/lib/bullet/src/Bullet3Serialize/Bullet2FileLoader/b3Common.h
View file

@ -1,40 +0,0 @@
/*
bParse
Copyright (c) 2006-2009 Charlie C & Erwin Coumans http://gamekit.googlecode.com
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 __BCOMMON_H__
#define __BCOMMON_H__
#include <assert.h>
//#include "bLog.h"
#include "Bullet3Common/b3AlignedObjectArray.h"
#include "Bullet3Common/b3HashMap.h"
namespace bParse
{
class bMain;
class bFileData;
class bFile;
class bDNA;
// delete void* undefined
typedef struct bStructHandle
{
int unused;
} bStructHandle;
typedef b3AlignedObjectArray<bStructHandle*> bListBasePtr;
typedef b3HashMap<b3HashPtr, bStructHandle*> bPtrMap;
} // namespace bParse
#endif //__BCOMMON_H__

616
Engine/lib/bullet/src/Bullet3Serialize/Bullet2FileLoader/b3DNA.cpp
View file

@ -1,616 +0,0 @@
/*
bParse
Copyright (c) 2006-2009 Charlie C & Erwin Coumans http://gamekit.googlecode.com
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.
*/
#include <assert.h>
#include "b3DNA.h"
#include "b3Chunk.h"
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
//this define will force traversal of structures, to check backward (and forward) compatibility
//#define TEST_BACKWARD_FORWARD_COMPATIBILITY
using namespace bParse;
// ----------------------------------------------------- //
bDNA::bDNA()
: mPtrLen(0)
{
// --
}
// ----------------------------------------------------- //
bDNA::~bDNA()
{
// --
}
// ----------------------------------------------------- //
bool bDNA::lessThan(bDNA *file)
{
return (m_Names.size() < file->m_Names.size());
}
// ----------------------------------------------------- //
char *bDNA::getName(int ind)
{
assert(ind <= (int)m_Names.size());
return m_Names[ind].m_name;
}
// ----------------------------------------------------- //
char *bDNA::getType(int ind)
{
assert(ind <= (int)mTypes.size());
return mTypes[ind];
}
// ----------------------------------------------------- //
short *bDNA::getStruct(int ind)
{
assert(ind <= (int)mStructs.size());
return mStructs[ind];
}
// ----------------------------------------------------- //
short bDNA::getLength(int ind)
{
assert(ind <= (int)mTlens.size());
return mTlens[ind];
}
// ----------------------------------------------------- //
int bDNA::getReverseType(short type)
{
int *intPtr = mStructReverse.find(type);
if (intPtr)
return *intPtr;
return -1;
}
// ----------------------------------------------------- //
int bDNA::getReverseType(const char *type)
{
b3HashString key(type);
int *valuePtr = mTypeLookup.find(key);
if (valuePtr)
return *valuePtr;
return -1;
}
// ----------------------------------------------------- //
int bDNA::getNumStructs()
{
return (int)mStructs.size();
}
// ----------------------------------------------------- //
bool bDNA::flagNotEqual(int dna_nr)
{
assert(dna_nr <= (int)mCMPFlags.size());
return mCMPFlags[dna_nr] == FDF_STRUCT_NEQU;
}
// ----------------------------------------------------- //
bool bDNA::flagEqual(int dna_nr)
{
assert(dna_nr <= (int)mCMPFlags.size());
int flag = mCMPFlags[dna_nr];
return flag == FDF_STRUCT_EQU;
}
// ----------------------------------------------------- //
bool bDNA::flagNone(int dna_nr)
{
assert(dna_nr <= (int)mCMPFlags.size());
return mCMPFlags[dna_nr] == FDF_NONE;
}
// ----------------------------------------------------- //
int bDNA::getPointerSize()
{
return mPtrLen;
}
// ----------------------------------------------------- //
void bDNA::initRecurseCmpFlags(int iter)
{
// iter is FDF_STRUCT_NEQU
short *oldStrc = mStructs[iter];
short type = oldStrc[0];
for (int i = 0; i < (int)mStructs.size(); i++)
{
if (i != iter && mCMPFlags[i] == FDF_STRUCT_EQU)
{
short *curStruct = mStructs[i];
int eleLen = curStruct[1];
curStruct += 2;
for (int j = 0; j < eleLen; j++, curStruct += 2)
{
if (curStruct[0] == type)
{
//char *name = m_Names[curStruct[1]].m_name;
//if (name[0] != '*')
if (m_Names[curStruct[1]].m_isPointer)
{
mCMPFlags[i] = FDF_STRUCT_NEQU;
initRecurseCmpFlags(i);
}
}
}
}
}
}
// ----------------------------------------------------- //
void bDNA::initCmpFlags(bDNA *memDNA)
{
// compare the file to memory
// this ptr should be the file data
assert(!(m_Names.size() == 0)); // && "SDNA empty!");
mCMPFlags.resize(mStructs.size(), FDF_NONE);
int i;
for (i = 0; i < (int)mStructs.size(); i++)
{
short *oldStruct = mStructs[i];
int oldLookup = getReverseType(oldStruct[0]);
if (oldLookup == -1)
{
mCMPFlags[i] = FDF_NONE;
continue;
}
//char* typeName = mTypes[oldStruct[0]];
//#define SLOW_FORWARD_COMPATIBLE 1
#ifdef SLOW_FORWARD_COMPATIBLE
char *typeName = mTypes[oldLookup];
int newLookup = memDNA->getReverseType(typeName);
if (newLookup == -1)
{
mCMPFlags[i] = FDF_NONE;
continue;
}
short *curStruct = memDNA->mStructs[newLookup];
#else
// memory for file
if (oldLookup < memDNA->mStructs.size())
{
short *curStruct = memDNA->mStructs[oldLookup];
#endif
// rebuild...
mCMPFlags[i] = FDF_STRUCT_NEQU;
#ifndef TEST_BACKWARD_FORWARD_COMPATIBILITY
if (curStruct[1] == oldStruct[1])
{
// type len same ...
if (mTlens[oldStruct[0]] == memDNA->mTlens[curStruct[0]])
{
bool isSame = true;
int elementLength = oldStruct[1];
curStruct += 2;
oldStruct += 2;
for (int j = 0; j < elementLength; j++, curStruct += 2, oldStruct += 2)
{
// type the same
//const char* typeFileDNA = mTypes[oldStruct[0]];
//const char* typeMemDNA = mTypes[curStruct[0]];
if (strcmp(mTypes[oldStruct[0]], memDNA->mTypes[curStruct[0]]) != 0)
{
isSame = false;
break;
}
// name the same
if (strcmp(m_Names[oldStruct[1]].m_name, memDNA->m_Names[curStruct[1]].m_name) != 0)
{
isSame = false;
break;
}
}
// flag valid ==
if (isSame)
mCMPFlags[i] = FDF_STRUCT_EQU;
}
}
#endif
}
}
// recurse in
for (i = 0; i < (int)mStructs.size(); i++)
{
if (mCMPFlags[i] == FDF_STRUCT_NEQU)
initRecurseCmpFlags(i);
}
}
static int name_is_array(char *name, int *dim1, int *dim2)
{
int len = strlen(name);
/*fprintf(stderr,"[%s]",name);*/
/*if (len >= 1) {
if (name[len-1] != ']')
return 1;
}
return 0;*/
char *bp;
int num;
if (dim1)
{
*dim1 = 1;
}
if (dim2)
{
*dim2 = 1;
}
bp = strchr(name, '[');
if (!bp)
{
return 0;
}
num = 0;
while (++bp < name + len - 1)
{
const char c = *bp;
if (c == ']')
{
break;
}
if (c <= '9' && c >= '0')
{
num *= 10;
num += (c - '0');
}
else
{
printf("array parse error.\n");
return 0;
}
}
if (dim2)
{
*dim2 = num;
}
/* find second dim, if any. */
bp = strchr(bp, '[');
if (!bp)
{
return 1; /* at least we got the first dim. */
}
num = 0;
while (++bp < name + len - 1)
{
const char c = *bp;
if (c == ']')
{
break;
}
if (c <= '9' && c >= '0')
{
num *= 10;
num += (c - '0');
}
else
{
printf("array2 parse error.\n");
return 1;
}
}
if (dim1)
{
if (dim2)
{
*dim1 = *dim2;
*dim2 = num;
}
else
{
*dim1 = num;
}
}
return 1;
}
// ----------------------------------------------------- //
void bDNA::init(char *data, int len, bool swap)
{
int *intPtr = 0;
short *shtPtr = 0;
char *cp = 0;
int dataLen = 0;
//long nr=0;
intPtr = (int *)data;
/*
SDNA (4 bytes) (magic number)
NAME (4 bytes)
<nr> (4 bytes) amount of names (int)
<string>
<string>
*/
if (strncmp(data, "SDNA", 4) == 0)
{
// skip ++ NAME
intPtr++;
intPtr++;
}
// Parse names
if (swap)
{
*intPtr = ChunkUtils::swapInt(*intPtr);
}
dataLen = *intPtr;
intPtr++;
cp = (char *)intPtr;
int i;
for (i = 0; i < dataLen; i++)
{
bNameInfo info;
info.m_name = cp;
info.m_isPointer = (info.m_name[0] == '*') || (info.m_name[1] == '*');
name_is_array(info.m_name, &info.m_dim0, &info.m_dim1);
m_Names.push_back(info);
while (*cp) cp++;
cp++;
}
cp = b3AlignPointer(cp, 4);
/*
TYPE (4 bytes)
<nr> amount of types (int)
<string>
<string>
*/
intPtr = (int *)cp;
assert(strncmp(cp, "TYPE", 4) == 0);
intPtr++;
if (swap)
{
*intPtr = ChunkUtils::swapInt(*intPtr);
}
dataLen = *intPtr;
intPtr++;
cp = (char *)intPtr;
for (i = 0; i < dataLen; i++)
{
mTypes.push_back(cp);
while (*cp) cp++;
cp++;
}
cp = b3AlignPointer(cp, 4);
/*
TLEN (4 bytes)
<len> (short) the lengths of types
<len>
*/
// Parse type lens
intPtr = (int *)cp;
assert(strncmp(cp, "TLEN", 4) == 0);
intPtr++;
dataLen = (int)mTypes.size();
shtPtr = (short *)intPtr;
for (i = 0; i < dataLen; i++, shtPtr++)
{
if (swap)
shtPtr[0] = ChunkUtils::swapShort(shtPtr[0]);
mTlens.push_back(shtPtr[0]);
}
if (dataLen & 1) shtPtr++;
/*
STRC (4 bytes)
<nr> amount of structs (int)
<typenr>
<nr_of_elems>
<typenr>
<namenr>
<typenr>
<namenr>
*/
intPtr = (int *)shtPtr;
cp = (char *)intPtr;
assert(strncmp(cp, "STRC", 4) == 0);
intPtr++;
if (swap)
{
*intPtr = ChunkUtils::swapInt(*intPtr);
}
dataLen = *intPtr;
intPtr++;
shtPtr = (short *)intPtr;
for (i = 0; i < dataLen; i++)
{
mStructs.push_back(shtPtr);
if (swap)
{
shtPtr[0] = ChunkUtils::swapShort(shtPtr[0]);
shtPtr[1] = ChunkUtils::swapShort(shtPtr[1]);
int len = shtPtr[1];
shtPtr += 2;
for (int a = 0; a < len; a++, shtPtr += 2)
{
shtPtr[0] = ChunkUtils::swapShort(shtPtr[0]);
shtPtr[1] = ChunkUtils::swapShort(shtPtr[1]);
}
}
else
shtPtr += (2 * shtPtr[1]) + 2;
}
// build reverse lookups
for (i = 0; i < (int)mStructs.size(); i++)
{
short *strc = mStructs.at(i);
if (!mPtrLen && strcmp(mTypes[strc[0]], "ListBase") == 0)
{
mPtrLen = mTlens[strc[0]] / 2;
}
mStructReverse.insert(strc[0], i);
mTypeLookup.insert(b3HashString(mTypes[strc[0]]), i);
}
}
// ----------------------------------------------------- //
int bDNA::getArraySize(char *string)
{
int ret = 1;
int len = strlen(string);
char *next = 0;
for (int i = 0; i < len; i++)
{
char c = string[i];
if (c == '[')
next = &string[i + 1];
else if (c == ']')
if (next)
ret *= atoi(next);
}
// print (string << ' ' << ret);
return ret;
}
void bDNA::dumpTypeDefinitions()
{
int i;
int numTypes = mTypes.size();
for (i = 0; i < numTypes; i++)
{
}
for (i = 0; i < (int)mStructs.size(); i++)
{
int totalBytes = 0;
short *oldStruct = mStructs[i];
int oldLookup = getReverseType(oldStruct[0]);
if (oldLookup == -1)
{
mCMPFlags[i] = FDF_NONE;
continue;
}
short *newStruct = mStructs[oldLookup];
char *typeName = mTypes[newStruct[0]];
printf("%3d: %s ", i, typeName);
//char *name = mNames[oldStruct[1]];
int len = oldStruct[1];
printf(" (%d fields) ", len);
oldStruct += 2;
printf("{");
int j;
for (j = 0; j < len; ++j, oldStruct += 2)
{
const char *name = m_Names[oldStruct[1]].m_name;
printf("%s %s", mTypes[oldStruct[0]], name);
int elemNumBytes = 0;
int arrayDimensions = getArraySizeNew(oldStruct[1]);
if (m_Names[oldStruct[1]].m_isPointer)
{
elemNumBytes = VOID_IS_8 ? 8 : 4;
}
else
{
elemNumBytes = getLength(oldStruct[0]);
}
printf(" /* %d bytes */", elemNumBytes * arrayDimensions);
if (j == len - 1)
{
printf(";}");
}
else
{
printf("; ");
}
totalBytes += elemNumBytes * arrayDimensions;
}
printf("\ntotalBytes=%d\n\n", totalBytes);
}
#if 0
/* dump out display of types and their sizes */
for (i=0; i<bf->types_count; ++i) {
/* if (!bf->types[i].is_struct)*/
{
printf("%3d: sizeof(%s%s)=%d",
i,
bf->types[i].is_struct ? "struct " : "atomic ",
bf->types[i].name, bf->types[i].size);
if (bf->types[i].is_struct) {
int j;
printf(", %d fields: { ", bf->types[i].fieldtypes_count);
for (j=0; j<bf->types[i].fieldtypes_count; ++j) {
printf("%s %s",
bf->types[bf->types[i].fieldtypes[j]].name,
bf->names[bf->types[i].fieldnames[j]]);
if (j == bf->types[i].fieldtypes_count-1) {
printf(";}");
} else {
printf("; ");
}
}
}
printf("\n\n");
}
}
#endif
}
//eof

101
Engine/lib/bullet/src/Bullet3Serialize/Bullet2FileLoader/b3DNA.h
View file

@ -1,101 +0,0 @@
/*
bParse
Copyright (c) 2006-2009 Charlie C & Erwin Coumans http://gamekit.googlecode.com
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 __BDNA_H__
#define __BDNA_H__
#include "b3Common.h"
namespace bParse
{
struct bNameInfo
{
char *m_name;
bool m_isPointer;
int m_dim0;
int m_dim1;
};
class bDNA
{
public:
bDNA();
~bDNA();
void init(char *data, int len, bool swap = false);
int getArraySize(char *str);
int getArraySizeNew(short name)
{
const bNameInfo &nameInfo = m_Names[name];
return nameInfo.m_dim0 * nameInfo.m_dim1;
}
int getElementSize(short type, short name)
{
const bNameInfo &nameInfo = m_Names[name];
int size = nameInfo.m_isPointer ? mPtrLen * nameInfo.m_dim0 * nameInfo.m_dim1 : mTlens[type] * nameInfo.m_dim0 * nameInfo.m_dim1;
return size;
}
int getNumNames() const
{
return m_Names.size();
}
char *getName(int ind);
char *getType(int ind);
short *getStruct(int ind);
short getLength(int ind);
int getReverseType(short type);
int getReverseType(const char *type);
int getNumStructs();
//
bool lessThan(bDNA *other);
void initCmpFlags(bDNA *memDNA);
bool flagNotEqual(int dna_nr);
bool flagEqual(int dna_nr);
bool flagNone(int dna_nr);
int getPointerSize();
void dumpTypeDefinitions();
private:
enum FileDNAFlags
{
FDF_NONE = 0,
FDF_STRUCT_NEQU,
FDF_STRUCT_EQU
};
void initRecurseCmpFlags(int i);
b3AlignedObjectArray<int> mCMPFlags;
b3AlignedObjectArray<bNameInfo> m_Names;
b3AlignedObjectArray<char *> mTypes;
b3AlignedObjectArray<short *> mStructs;
b3AlignedObjectArray<short> mTlens;
b3HashMap<b3HashInt, int> mStructReverse;
b3HashMap<b3HashString, int> mTypeLookup;
int mPtrLen;
};
} // namespace bParse
#endif //__BDNA_H__

149
Engine/lib/bullet/src/Bullet3Serialize/Bullet2FileLoader/b3Defines.h
View file

@ -1,149 +0,0 @@
/* Copyright (C) 2006-2009 Charlie C & Erwin Coumans http://gamekit.googlecode.com
*
* 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 __B_DEFINES_H__
#define __B_DEFINES_H__
// MISC defines, see BKE_global.h, BKE_utildefines.h
#define B3_SIZEOFBLENDERHEADER 12
// ------------------------------------------------------------
#if defined(__sgi) || defined(__sparc) || defined(__sparc__) || defined(__PPC__) || defined(__ppc__) || defined(__BIG_ENDIAN__)
#define B3_MAKE_ID(a, b, c, d) ((int)(a) << 24 | (int)(b) << 16 | (c) << 8 | (d))
#else
#define B3_MAKE_ID(a, b, c, d) ((int)(d) << 24 | (int)(c) << 16 | (b) << 8 | (a))
#endif
// ------------------------------------------------------------
#if defined(__sgi) || defined(__sparc) || defined(__sparc__) || defined(__PPC__) || defined(__ppc__) || defined(__BIG_ENDIAN__)
#define B3_MAKE_ID2(c, d) ((c) << 8 | (d))
#else
#define B3_MAKE_ID2(c, d) ((d) << 8 | (c))
#endif
// ------------------------------------------------------------
#define B3_ID_SCE B3_MAKE_ID2('S', 'C')
#define B3_ID_LI B3_MAKE_ID2('L', 'I')
#define B3_ID_OB B3_MAKE_ID2('O', 'B')
#define B3_ID_ME B3_MAKE_ID2('M', 'E')
#define B3_ID_CU B3_MAKE_ID2('C', 'U')
#define B3_ID_MB B3_MAKE_ID2('M', 'B')
#define B3_ID_MA B3_MAKE_ID2('M', 'A')
#define B3_ID_TE B3_MAKE_ID2('T', 'E')
#define B3_ID_IM B3_MAKE_ID2('I', 'M')
#define B3_ID_IK B3_MAKE_ID2('I', 'K')
#define B3_ID_WV B3_MAKE_ID2('W', 'V')
#define B3_ID_LT B3_MAKE_ID2('L', 'T')
#define B3_ID_SE B3_MAKE_ID2('S', 'E')
#define B3_ID_LF B3_MAKE_ID2('L', 'F')
#define B3_ID_LA B3_MAKE_ID2('L', 'A')
#define B3_ID_CA B3_MAKE_ID2('C', 'A')
#define B3_ID_IP B3_MAKE_ID2('I', 'P')
#define B3_ID_KE B3_MAKE_ID2('K', 'E')
#define B3_ID_WO B3_MAKE_ID2('W', 'O')
#define B3_ID_SCR B3_MAKE_ID2('S', 'R')
#define B3_ID_VF B3_MAKE_ID2('V', 'F')
#define B3_ID_TXT B3_MAKE_ID2('T', 'X')
#define B3_ID_SO B3_MAKE_ID2('S', 'O')
#define B3_ID_SAMPLE B3_MAKE_ID2('S', 'A')
#define B3_ID_GR B3_MAKE_ID2('G', 'R')
#define B3_ID_ID B3_MAKE_ID2('I', 'D')
#define B3_ID_AR B3_MAKE_ID2('A', 'R')
#define B3_ID_AC B3_MAKE_ID2('A', 'C')
#define B3_ID_SCRIPT B3_MAKE_ID2('P', 'Y')
#define B3_ID_FLUIDSIM B3_MAKE_ID2('F', 'S')
#define B3_ID_NT B3_MAKE_ID2('N', 'T')
#define B3_ID_BR B3_MAKE_ID2('B', 'R')
#define B3_ID_SEQ B3_MAKE_ID2('S', 'Q')
#define B3_ID_CO B3_MAKE_ID2('C', 'O')
#define B3_ID_PO B3_MAKE_ID2('A', 'C')
#define B3_ID_NLA B3_MAKE_ID2('N', 'L')
#define B3_ID_VS B3_MAKE_ID2('V', 'S')
#define B3_ID_VN B3_MAKE_ID2('V', 'N')
// ------------------------------------------------------------
#define B3_FORM B3_MAKE_ID('F', 'O', 'R', 'M')
#define B3_DDG1 B3_MAKE_ID('3', 'D', 'G', '1')
#define B3_DDG2 B3_MAKE_ID('3', 'D', 'G', '2')
#define B3_DDG3 B3_MAKE_ID('3', 'D', 'G', '3')
#define B3_DDG4 B3_MAKE_ID('3', 'D', 'G', '4')
#define B3_GOUR B3_MAKE_ID('G', 'O', 'U', 'R')
#define B3_BLEN B3_MAKE_ID('B', 'L', 'E', 'N')
#define B3_DER_ B3_MAKE_ID('D', 'E', 'R', '_')
#define B3_V100 B3_MAKE_ID('V', '1', '0', '0')
#define B3_DATA B3_MAKE_ID('D', 'A', 'T', 'A')
#define B3_GLOB B3_MAKE_ID('G', 'L', 'O', 'B')
#define B3_IMAG B3_MAKE_ID('I', 'M', 'A', 'G')
#define B3_TEST B3_MAKE_ID('T', 'E', 'S', 'T')
#define B3_USER B3_MAKE_ID('U', 'S', 'E', 'R')
// ------------------------------------------------------------
#define B3_DNA1 B3_MAKE_ID('D', 'N', 'A', '1')
#define B3_REND B3_MAKE_ID('R', 'E', 'N', 'D')
#define B3_ENDB B3_MAKE_ID('E', 'N', 'D', 'B')
#define B3_NAME B3_MAKE_ID('N', 'A', 'M', 'E')
#define B3_SDNA B3_MAKE_ID('S', 'D', 'N', 'A')
#define B3_TYPE B3_MAKE_ID('T', 'Y', 'P', 'E')
#define B3_TLEN B3_MAKE_ID('T', 'L', 'E', 'N')
#define B3_STRC B3_MAKE_ID('S', 'T', 'R', 'C')
// ------------------------------------------------------------
#define B3_SWITCH_INT(a) \
{ \
char s_i, *p_i; \
p_i = (char *)&(a); \
s_i = p_i[0]; \
p_i[0] = p_i[3]; \
p_i[3] = s_i; \
s_i = p_i[1]; \
p_i[1] = p_i[2]; \
p_i[2] = s_i; \
}
// ------------------------------------------------------------
#define B3_SWITCH_SHORT(a) \
{ \
char s_i, *p_i; \
p_i = (char *)&(a); \
s_i = p_i[0]; \
p_i[0] = p_i[1]; \
p_i[1] = s_i; \
}
// ------------------------------------------------------------
#define B3_SWITCH_LONGINT(a) \
{ \
char s_i, *p_i; \
p_i = (char *)&(a); \
s_i = p_i[0]; \
p_i[0] = p_i[7]; \
p_i[7] = s_i; \
s_i = p_i[1]; \
p_i[1] = p_i[6]; \
p_i[6] = s_i; \
s_i = p_i[2]; \
p_i[2] = p_i[5]; \
p_i[5] = s_i; \
s_i = p_i[3]; \
p_i[3] = p_i[4]; \
p_i[4] = s_i; \
}
#endif //__B_DEFINES_H__

1653
Engine/lib/bullet/src/Bullet3Serialize/Bullet2FileLoader/b3File.cpp
View file

File diff suppressed because it is too large Load diff

158
Engine/lib/bullet/src/Bullet3Serialize/Bullet2FileLoader/b3File.h
View file

@ -1,158 +0,0 @@
/*
bParse
Copyright (c) 2006-2009 Charlie C & Erwin Coumans http://gamekit.googlecode.com
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 __BFILE_H__
#define __BFILE_H__
#include "b3Common.h"
#include "b3Chunk.h"
#include <stdio.h>
namespace bParse
{
// ----------------------------------------------------- //
enum bFileFlags
{
FD_INVALID = 0,
FD_OK = 1,
FD_VOID_IS_8 = 2,
FD_ENDIAN_SWAP = 4,
FD_FILE_64 = 8,
FD_BITS_VARIES = 16,
FD_VERSION_VARIES = 32,
FD_DOUBLE_PRECISION = 64,
FD_BROKEN_DNA = 128
};
enum bFileVerboseMode
{
FD_VERBOSE_EXPORT_XML = 1,
FD_VERBOSE_DUMP_DNA_TYPE_DEFINITIONS = 2,
FD_VERBOSE_DUMP_CHUNKS = 4,
FD_VERBOSE_DUMP_FILE_INFO = 8,
};
// ----------------------------------------------------- //
class bFile
{
protected:
char m_headerString[7];
bool mOwnsBuffer;
char *mFileBuffer;
int mFileLen;
int mVersion;
bPtrMap mLibPointers;
int mDataStart;
bDNA *mFileDNA;
bDNA *mMemoryDNA;
b3AlignedObjectArray<char *> m_pointerFixupArray;
b3AlignedObjectArray<char *> m_pointerPtrFixupArray;
b3AlignedObjectArray<bChunkInd> m_chunks;
b3HashMap<b3HashPtr, bChunkInd> m_chunkPtrPtrMap;
//
bPtrMap mDataPointers;
int mFlags;
// ////////////////////////////////////////////////////////////////////////////
// buffer offset util
int getNextBlock(bChunkInd *dataChunk, const char *dataPtr, const int flags);
void safeSwapPtr(char *dst, const char *src);
virtual void parseHeader();
virtual void parseData() = 0;
void resolvePointersMismatch();
void resolvePointersChunk(const bChunkInd &dataChunk, int verboseMode);
int resolvePointersStructRecursive(char *strcPtr, int old_dna, int verboseMode, int recursion);
//void swapPtr(char *dst, char *src);
void parseStruct(char *strcPtr, char *dtPtr, int old_dna, int new_dna, bool fixupPointers);
void getMatchingFileDNA(short *old, const char *lookupName, const char *lookupType, char *strcData, char *data, bool fixupPointers);
char *getFileElement(short *firstStruct, char *lookupName, char *lookupType, char *data, short **foundPos);
void swap(char *head, class bChunkInd &ch, bool ignoreEndianFlag);
void swapData(char *data, short type, int arraySize, bool ignoreEndianFlag);
void swapStruct(int dna_nr, char *data, bool ignoreEndianFlag);
void swapLen(char *dataPtr);
void swapDNA(char *ptr);
char *readStruct(char *head, class bChunkInd &chunk);
char *getAsString(int code);
void parseInternal(int verboseMode, char *memDna, int memDnaLength);
public:
bFile(const char *filename, const char headerString[7]);
//todo: make memoryBuffer const char
//bFile( const char *memoryBuffer, int len);
bFile(char *memoryBuffer, int len, const char headerString[7]);
virtual ~bFile();
bDNA *getFileDNA()
{
return mFileDNA;
}
virtual void addDataBlock(char *dataBlock) = 0;
int getFlags() const
{
return mFlags;
}
bPtrMap &getLibPointers()
{
return mLibPointers;
}
void *findLibPointer(void *ptr);
bool ok();
virtual void parse(int verboseMode) = 0;
virtual int write(const char *fileName, bool fixupPointers = false) = 0;
virtual void writeChunks(FILE *fp, bool fixupPointers);
virtual void writeDNA(FILE *fp) = 0;
void updateOldPointers();
void resolvePointers(int verboseMode);
void dumpChunks(bDNA *dna);
int getVersion() const
{
return mVersion;
}
//pre-swap the endianness, so that data loaded on a target with different endianness doesn't need to be swapped
void preSwap();
void writeFile(const char *fileName);
};
} // namespace bParse
#endif //__BFILE_H__

18062
Engine/lib/bullet/src/Bullet3Serialize/Bullet2FileLoader/b3Serializer.cpp
View file

File diff suppressed because it is too large Load diff

601
Engine/lib/bullet/src/Bullet3Serialize/Bullet2FileLoader/b3Serializer.h
View file

@ -1,601 +0,0 @@
/*
Bullet Continuous Collision Detection and Physics Library
Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org
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 B3_SERIALIZER_H
#define B3_SERIALIZER_H
#include "Bullet3Common/b3Scalar.h" // has definitions like B3_FORCE_INLINE
#include "Bullet3Common/b3StackAlloc.h"
#include "Bullet3Common/b3HashMap.h"
#if !defined(__CELLOS_LV2__) && !defined(__MWERKS__)
#include <memory.h>
#endif
#include <string.h>
extern char b3s_bulletDNAstr[];
extern int b3s_bulletDNAlen;
extern char b3s_bulletDNAstr64[];
extern int b3s_bulletDNAlen64;
B3_FORCE_INLINE int b3StrLen(const char* str)
{
if (!str)
return (0);
int len = 0;
while (*str != 0)
{
str++;
len++;
}
return len;
}
class b3Chunk
{
public:
int m_chunkCode;
int m_length;
void* m_oldPtr;
int m_dna_nr;
int m_number;
};
enum b3SerializationFlags
{
B3_SERIALIZE_NO_BVH = 1,
B3_SERIALIZE_NO_TRIANGLEINFOMAP = 2,
B3_SERIALIZE_NO_DUPLICATE_ASSERT = 4
};
class b3Serializer
{
public:
virtual ~b3Serializer() {}
virtual const unsigned char* getBufferPointer() const = 0;
virtual int getCurrentBufferSize() const = 0;
virtual b3Chunk* allocate(size_t size, int numElements) = 0;
virtual void finalizeChunk(b3Chunk* chunk, const char* structType, int chunkCode, void* oldPtr) = 0;
virtual void* findPointer(void* oldPtr) = 0;
virtual void* getUniquePointer(void* oldPtr) = 0;
virtual void startSerialization() = 0;
virtual void finishSerialization() = 0;
virtual const char* findNameForPointer(const void* ptr) const = 0;
virtual void registerNameForPointer(const void* ptr, const char* name) = 0;
virtual void serializeName(const char* ptr) = 0;
virtual int getSerializationFlags() const = 0;
virtual void setSerializationFlags(int flags) = 0;
};
#define B3_HEADER_LENGTH 12
#if defined(__sgi) || defined(__sparc) || defined(__sparc__) || defined(__PPC__) || defined(__ppc__) || defined(__BIG_ENDIAN__)
#define B3_MAKE_ID(a, b, c, d) ((int)(a) << 24 | (int)(b) << 16 | (c) << 8 | (d))
#else
#define B3_MAKE_ID(a, b, c, d) ((int)(d) << 24 | (int)(c) << 16 | (b) << 8 | (a))
#endif
#define B3_SOFTBODY_CODE B3_MAKE_ID('S', 'B', 'D', 'Y')
#define B3_COLLISIONOBJECT_CODE B3_MAKE_ID('C', 'O', 'B', 'J')
#define B3_RIGIDBODY_CODE B3_MAKE_ID('R', 'B', 'D', 'Y')
#define B3_CONSTRAINT_CODE B3_MAKE_ID('C', 'O', 'N', 'S')
#define B3_BOXSHAPE_CODE B3_MAKE_ID('B', 'O', 'X', 'S')
#define B3_QUANTIZED_BVH_CODE B3_MAKE_ID('Q', 'B', 'V', 'H')
#define B3_TRIANLGE_INFO_MAP B3_MAKE_ID('T', 'M', 'A', 'P')
#define B3_SHAPE_CODE B3_MAKE_ID('S', 'H', 'A', 'P')
#define B3_ARRAY_CODE B3_MAKE_ID('A', 'R', 'A', 'Y')
#define B3_SBMATERIAL_CODE B3_MAKE_ID('S', 'B', 'M', 'T')
#define B3_SBNODE_CODE B3_MAKE_ID('S', 'B', 'N', 'D')
#define B3_DYNAMICSWORLD_CODE B3_MAKE_ID('D', 'W', 'L', 'D')
#define B3_DNA_CODE B3_MAKE_ID('D', 'N', 'A', '1')
struct b3PointerUid
{
union {
void* m_ptr;
int m_uniqueIds[2];
};
};
///The b3DefaultSerializer is the main Bullet serialization class.
///The constructor takes an optional argument for backwards compatibility, it is recommended to leave this empty/zero.
class b3DefaultSerializer : public b3Serializer
{
b3AlignedObjectArray<char*> mTypes;
b3AlignedObjectArray<short*> mStructs;
b3AlignedObjectArray<short> mTlens;
b3HashMap<b3HashInt, int> mStructReverse;
b3HashMap<b3HashString, int> mTypeLookup;
b3HashMap<b3HashPtr, void*> m_chunkP;
b3HashMap<b3HashPtr, const char*> m_nameMap;
b3HashMap<b3HashPtr, b3PointerUid> m_uniquePointers;
int m_uniqueIdGenerator;
int m_totalSize;
unsigned char* m_buffer;
int m_currentSize;
void* m_dna;
int m_dnaLength;
int m_serializationFlags;
b3AlignedObjectArray<b3Chunk*> m_chunkPtrs;
protected:
virtual void* findPointer(void* oldPtr)
{
void** ptr = m_chunkP.find(oldPtr);
if (ptr && *ptr)
return *ptr;
return 0;
}
void writeDNA()
{
b3Chunk* dnaChunk = allocate(m_dnaLength, 1);
memcpy(dnaChunk->m_oldPtr, m_dna, m_dnaLength);
finalizeChunk(dnaChunk, "DNA1", B3_DNA_CODE, m_dna);
}
int getReverseType(const char* type) const
{
b3HashString key(type);
const int* valuePtr = mTypeLookup.find(key);
if (valuePtr)
return *valuePtr;
return -1;
}
void initDNA(const char* bdnaOrg, int dnalen)
{
///was already initialized
if (m_dna)
return;
int littleEndian = 1;
littleEndian = ((char*)&littleEndian)[0];
m_dna = b3AlignedAlloc(dnalen, 16);
memcpy(m_dna, bdnaOrg, dnalen);
m_dnaLength = dnalen;
int* intPtr = 0;
short* shtPtr = 0;
char* cp = 0;
int dataLen = 0;
intPtr = (int*)m_dna;
/*
SDNA (4 bytes) (magic number)
NAME (4 bytes)
<nr> (4 bytes) amount of names (int)
<string>
<string>
*/
if (strncmp((const char*)m_dna, "SDNA", 4) == 0)
{
// skip ++ NAME
intPtr++;
intPtr++;
}
// Parse names
if (!littleEndian)
*intPtr = b3SwapEndian(*intPtr);
dataLen = *intPtr;
intPtr++;
cp = (char*)intPtr;
int i;
for (i = 0; i < dataLen; i++)
{
while (*cp) cp++;
cp++;
}
cp = b3AlignPointer(cp, 4);
/*
TYPE (4 bytes)
<nr> amount of types (int)
<string>
<string>
*/
intPtr = (int*)cp;
b3Assert(strncmp(cp, "TYPE", 4) == 0);
intPtr++;
if (!littleEndian)
*intPtr = b3SwapEndian(*intPtr);
dataLen = *intPtr;
intPtr++;
cp = (char*)intPtr;
for (i = 0; i < dataLen; i++)
{
mTypes.push_back(cp);
while (*cp) cp++;
cp++;
}
cp = b3AlignPointer(cp, 4);
/*
TLEN (4 bytes)
<len> (short) the lengths of types
<len>
*/
// Parse type lens
intPtr = (int*)cp;
b3Assert(strncmp(cp, "TLEN", 4) == 0);
intPtr++;
dataLen = (int)mTypes.size();
shtPtr = (short*)intPtr;
for (i = 0; i < dataLen; i++, shtPtr++)
{
if (!littleEndian)
shtPtr[0] = b3SwapEndian(shtPtr[0]);
mTlens.push_back(shtPtr[0]);
}
if (dataLen & 1) shtPtr++;
/*
STRC (4 bytes)
<nr> amount of structs (int)
<typenr>
<nr_of_elems>
<typenr>
<namenr>
<typenr>
<namenr>
*/
intPtr = (int*)shtPtr;
cp = (char*)intPtr;
b3Assert(strncmp(cp, "STRC", 4) == 0);
intPtr++;
if (!littleEndian)
*intPtr = b3SwapEndian(*intPtr);
dataLen = *intPtr;
intPtr++;
shtPtr = (short*)intPtr;
for (i = 0; i < dataLen; i++)
{
mStructs.push_back(shtPtr);
if (!littleEndian)
{
shtPtr[0] = b3SwapEndian(shtPtr[0]);
shtPtr[1] = b3SwapEndian(shtPtr[1]);
int len = shtPtr[1];
shtPtr += 2;
for (int a = 0; a < len; a++, shtPtr += 2)
{
shtPtr[0] = b3SwapEndian(shtPtr[0]);
shtPtr[1] = b3SwapEndian(shtPtr[1]);
}
}
else
{
shtPtr += (2 * shtPtr[1]) + 2;
}
}
// build reverse lookups
for (i = 0; i < (int)mStructs.size(); i++)
{
short* strc = mStructs.at(i);
mStructReverse.insert(strc[0], i);
mTypeLookup.insert(b3HashString(mTypes[strc[0]]), i);
}
}
public:
b3DefaultSerializer(int totalSize = 0)
: m_totalSize(totalSize),
m_currentSize(0),
m_dna(0),
m_dnaLength(0),
m_serializationFlags(0)
{
m_buffer = m_totalSize ? (unsigned char*)b3AlignedAlloc(totalSize, 16) : 0;
const bool VOID_IS_8 = ((sizeof(void*) == 8));
#ifdef B3_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
if (VOID_IS_8)
{
#if _WIN64
initDNA((const char*)b3s_bulletDNAstr64, b3s_bulletDNAlen64);
#else
b3Assert(0);
#endif
}
else
{
#ifndef _WIN64
initDNA((const char*)b3s_bulletDNAstr, b3s_bulletDNAlen);
#else
b3Assert(0);
#endif
}
#else //B3_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
if (VOID_IS_8)
{
initDNA((const char*)b3s_bulletDNAstr64, b3s_bulletDNAlen64);
}
else
{
initDNA((const char*)b3s_bulletDNAstr, b3s_bulletDNAlen);
}
#endif //B3_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
}
virtual ~b3DefaultSerializer()
{
if (m_buffer)
b3AlignedFree(m_buffer);
if (m_dna)
b3AlignedFree(m_dna);
}
void writeHeader(unsigned char* buffer) const
{
#ifdef B3_USE_DOUBLE_PRECISION
memcpy(buffer, "BULLETd", 7);
#else
memcpy(buffer, "BULLETf", 7);
#endif //B3_USE_DOUBLE_PRECISION
int littleEndian = 1;
littleEndian = ((char*)&littleEndian)[0];
if (sizeof(void*) == 8)
{
buffer[7] = '-';
}
else
{
buffer[7] = '_';
}
if (littleEndian)
{
buffer[8] = 'v';
}
else
{
buffer[8] = 'V';
}
buffer[9] = '2';
buffer[10] = '8';
buffer[11] = '1';
}
virtual void startSerialization()
{
m_uniqueIdGenerator = 1;
if (m_totalSize)
{
unsigned char* buffer = internalAlloc(B3_HEADER_LENGTH);
writeHeader(buffer);
}
}
virtual void finishSerialization()
{
writeDNA();
//if we didn't pre-allocate a buffer, we need to create a contiguous buffer now
int mysize = 0;
if (!m_totalSize)
{
if (m_buffer)
b3AlignedFree(m_buffer);
m_currentSize += B3_HEADER_LENGTH;
m_buffer = (unsigned char*)b3AlignedAlloc(m_currentSize, 16);
unsigned char* currentPtr = m_buffer;
writeHeader(m_buffer);
currentPtr += B3_HEADER_LENGTH;
mysize += B3_HEADER_LENGTH;
for (int i = 0; i < m_chunkPtrs.size(); i++)
{
int curLength = sizeof(b3Chunk) + m_chunkPtrs[i]->m_length;
memcpy(currentPtr, m_chunkPtrs[i], curLength);
b3AlignedFree(m_chunkPtrs[i]);
currentPtr += curLength;
mysize += curLength;
}
}
mTypes.clear();
mStructs.clear();
mTlens.clear();
mStructReverse.clear();
mTypeLookup.clear();
m_chunkP.clear();
m_nameMap.clear();
m_uniquePointers.clear();
m_chunkPtrs.clear();
}
virtual void* getUniquePointer(void* oldPtr)
{
if (!oldPtr)
return 0;
b3PointerUid* uptr = (b3PointerUid*)m_uniquePointers.find(oldPtr);
if (uptr)
{
return uptr->m_ptr;
}
m_uniqueIdGenerator++;
b3PointerUid uid;
uid.m_uniqueIds[0] = m_uniqueIdGenerator;
uid.m_uniqueIds[1] = m_uniqueIdGenerator;
m_uniquePointers.insert(oldPtr, uid);
return uid.m_ptr;
}
virtual const unsigned char* getBufferPointer() const
{
return m_buffer;
}
virtual int getCurrentBufferSize() const
{
return m_currentSize;
}
virtual void finalizeChunk(b3Chunk* chunk, const char* structType, int chunkCode, void* oldPtr)
{
if (!(m_serializationFlags & B3_SERIALIZE_NO_DUPLICATE_ASSERT))
{
b3Assert(!findPointer(oldPtr));
}
chunk->m_dna_nr = getReverseType(structType);
chunk->m_chunkCode = chunkCode;
void* uniquePtr = getUniquePointer(oldPtr);
m_chunkP.insert(oldPtr, uniquePtr); //chunk->m_oldPtr);
chunk->m_oldPtr = uniquePtr; //oldPtr;
}
virtual unsigned char* internalAlloc(size_t size)
{
unsigned char* ptr = 0;
if (m_totalSize)
{
ptr = m_buffer + m_currentSize;
m_currentSize += int(size);
b3Assert(m_currentSize < m_totalSize);
}
else
{
ptr = (unsigned char*)b3AlignedAlloc(size, 16);
m_currentSize += int(size);
}
return ptr;
}
virtual b3Chunk* allocate(size_t size, int numElements)
{
unsigned char* ptr = internalAlloc(int(size) * numElements + sizeof(b3Chunk));
unsigned char* data = ptr + sizeof(b3Chunk);
b3Chunk* chunk = (b3Chunk*)ptr;
chunk->m_chunkCode = 0;
chunk->m_oldPtr = data;
chunk->m_length = int(size) * numElements;
chunk->m_number = numElements;
m_chunkPtrs.push_back(chunk);
return chunk;
}
virtual const char* findNameForPointer(const void* ptr) const
{
const char* const* namePtr = m_nameMap.find(ptr);
if (namePtr && *namePtr)
return *namePtr;
return 0;
}
virtual void registerNameForPointer(const void* ptr, const char* name)
{
m_nameMap.insert(ptr, name);
}
virtual void serializeName(const char* name)
{
if (name)
{
//don't serialize name twice
if (findPointer((void*)name))
return;
int len = b3StrLen(name);
if (len)
{
int newLen = len + 1;
int padding = ((newLen + 3) & ~3) - newLen;
newLen += padding;
//serialize name string now
b3Chunk* chunk = allocate(sizeof(char), newLen);
char* destinationName = (char*)chunk->m_oldPtr;
for (int i = 0; i < len; i++)
{
destinationName[i] = name[i];
}
destinationName[len] = 0;
finalizeChunk(chunk, "char", B3_ARRAY_CODE, (void*)name);
}
}
}
virtual int getSerializationFlags() const
{
return m_serializationFlags;
}
virtual void setSerializationFlags(int flags)
{
m_serializationFlags = flags;
}
};
#endif //B3_SERIALIZER_H

16
Engine/lib/bullet/src/Bullet3Serialize/Bullet2FileLoader/premake4.lua
View file

@ -1,16 +0,0 @@
project "Bullet2FileLoader"
kind "StaticLib"
includedirs {
"../../../src"
}
if os.is("Linux") then
buildoptions{"-fPIC"}
end
files {
"**.cpp",
"**.h"
}