mirror of
https://github.com/Ragora/T2-CPP.git
synced 2026-07-13 03:14:31 +00:00
Ported Bullet to the mod loader system; needs further work
This commit is contained in:
Robert MacGregor
parent
527474ff24
commit
06810b6cca
353 changed files with 80265 additions and 0 deletions
|
|
@ -0,0 +1,287 @@
|
|||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
|
||||
<ItemGroup Label="ProjectConfigurations">
|
||||
<ProjectConfiguration Include="Debug|Win32">
|
||||
<Configuration>Debug</Configuration>
|
||||
<Platform>Win32</Platform>
|
||||
</ProjectConfiguration>
|
||||
<ProjectConfiguration Include="Release|Win32">
|
||||
<Configuration>Release</Configuration>
|
||||
<Platform>Win32</Platform>
|
||||
</ProjectConfiguration>
|
||||
<ProjectConfiguration Include="MinSizeRel|Win32">
|
||||
<Configuration>MinSizeRel</Configuration>
|
||||
<Platform>Win32</Platform>
|
||||
</ProjectConfiguration>
|
||||
<ProjectConfiguration Include="RelWithDebInfo|Win32">
|
||||
<Configuration>RelWithDebInfo</Configuration>
|
||||
<Platform>Win32</Platform>
|
||||
</ProjectConfiguration>
|
||||
</ItemGroup>
|
||||
<PropertyGroup Label="Globals">
|
||||
<ProjectGUID>{22D04CA3-8380-4F14-9C57-C75321207A60}</ProjectGUID>
|
||||
<Keyword>Win32Proj</Keyword>
|
||||
<Platform>Win32</Platform>
|
||||
<ProjectName>BulletSoftBody</ProjectName>
|
||||
</PropertyGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
|
||||
<ConfigurationType>StaticLibrary</ConfigurationType>
|
||||
<UseOfMfc>false</UseOfMfc>
|
||||
<CharacterSet>MultiByte</CharacterSet>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
|
||||
<ConfigurationType>StaticLibrary</ConfigurationType>
|
||||
<UseOfMfc>false</UseOfMfc>
|
||||
<CharacterSet>MultiByte</CharacterSet>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='MinSizeRel|Win32'" Label="Configuration">
|
||||
<ConfigurationType>StaticLibrary</ConfigurationType>
|
||||
<UseOfMfc>false</UseOfMfc>
|
||||
<CharacterSet>MultiByte</CharacterSet>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='RelWithDebInfo|Win32'" Label="Configuration">
|
||||
<ConfigurationType>StaticLibrary</ConfigurationType>
|
||||
<UseOfMfc>false</UseOfMfc>
|
||||
<CharacterSet>MultiByte</CharacterSet>
|
||||
</PropertyGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
|
||||
<ImportGroup Label="ExtensionSettings">
|
||||
</ImportGroup>
|
||||
<ImportGroup Label="PropertySheets">
|
||||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" /> </ImportGroup>
|
||||
<PropertyGroup Label="UserMacros" />
|
||||
<PropertyGroup>
|
||||
<_ProjectFileVersion>10.0.20506.1</_ProjectFileVersion>
|
||||
<OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">C:\Documents and Settings\Robert MacGregor\Desktop\bullet-2.77\lib\Debug\</OutDir>
|
||||
<IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">BulletSoftBody.dir\Debug\</IntDir>
|
||||
<TargetName Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">BulletSoftBody</TargetName>
|
||||
<TargetExt Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">.lib</TargetExt>
|
||||
<OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">C:\Documents and Settings\Robert MacGregor\Desktop\bullet-2.77\lib\Release\</OutDir>
|
||||
<IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">BulletSoftBody.dir\Release\</IntDir>
|
||||
<TargetName Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">BulletSoftBody</TargetName>
|
||||
<TargetExt Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">.lib</TargetExt>
|
||||
<OutDir Condition="'$(Configuration)|$(Platform)'=='MinSizeRel|Win32'">C:\Documents and Settings\Robert MacGregor\Desktop\bullet-2.77\lib\MinSizeRel\</OutDir>
|
||||
<IntDir Condition="'$(Configuration)|$(Platform)'=='MinSizeRel|Win32'">BulletSoftBody.dir\MinSizeRel\</IntDir>
|
||||
<TargetName Condition="'$(Configuration)|$(Platform)'=='MinSizeRel|Win32'">BulletSoftBody</TargetName>
|
||||
<TargetExt Condition="'$(Configuration)|$(Platform)'=='MinSizeRel|Win32'">.lib</TargetExt>
|
||||
<OutDir Condition="'$(Configuration)|$(Platform)'=='RelWithDebInfo|Win32'">C:\Documents and Settings\Robert MacGregor\Desktop\bullet-2.77\lib\RelWithDebInfo\</OutDir>
|
||||
<IntDir Condition="'$(Configuration)|$(Platform)'=='RelWithDebInfo|Win32'">BulletSoftBody.dir\RelWithDebInfo\</IntDir>
|
||||
<TargetName Condition="'$(Configuration)|$(Platform)'=='RelWithDebInfo|Win32'">BulletSoftBody</TargetName>
|
||||
<TargetExt Condition="'$(Configuration)|$(Platform)'=='RelWithDebInfo|Win32'">.lib</TargetExt>
|
||||
</PropertyGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||
<ClCompile>
|
||||
<AdditionalOptions> /Zm1000 %(AdditionalOptions)</AdditionalOptions>
|
||||
<AdditionalIncludeDirectories>C:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77/Glut;C:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77/src;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
|
||||
<CompileAs>CompileAsCpp</CompileAs>
|
||||
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
|
||||
<EnableEnhancedInstructionSet>StreamingSIMDExtensions</EnableEnhancedInstructionSet>
|
||||
<ExceptionHandling>Sync</ExceptionHandling>
|
||||
<FloatingPointModel>Fast</FloatingPointModel>
|
||||
<InlineFunctionExpansion>Disabled</InlineFunctionExpansion>
|
||||
<Optimization>Disabled</Optimization>
|
||||
<PrecompiledHeader>NotUsing</PrecompiledHeader>
|
||||
<RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
|
||||
<RuntimeTypeInfo>true</RuntimeTypeInfo>
|
||||
<WarningLevel>Level3</WarningLevel>
|
||||
<PreprocessorDefinitions>WIN32;_DEBUG;_DEBUG;USE_GRAPHICAL_BENCHMARK;_IRR_STATIC_LIB_;_CRT_SECURE_NO_WARNINGS;_CRT_SECURE_NO_DEPRECATE;_SCL_SECURE_NO_WARNINGS;CMAKE_INTDIR="Debug";%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
<AssemblerListingLocation>Debug</AssemblerListingLocation>
|
||||
<ObjectFileName>$(IntDir)</ObjectFileName>
|
||||
<ProgramDataBaseFileName>C:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77/lib/Debug/BulletSoftBody.pdb</ProgramDataBaseFileName>
|
||||
</ClCompile>
|
||||
<ResourceCompile>
|
||||
<PreprocessorDefinitions>WIN32;_DEBUG;_DEBUG;USE_GRAPHICAL_BENCHMARK;_IRR_STATIC_LIB_;_CRT_SECURE_NO_WARNINGS;_CRT_SECURE_NO_DEPRECATE;_SCL_SECURE_NO_WARNINGS;CMAKE_INTDIR=\"Debug\";%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
<AdditionalIncludeDirectories>C:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77/Glut;C:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77/src;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||
</ResourceCompile>
|
||||
<Midl>
|
||||
<AdditionalIncludeDirectories>C:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77/Glut;C:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77/src;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||
<OutputDirectory>$(IntDir)</OutputDirectory>
|
||||
<HeaderFileName>%(Filename).h</HeaderFileName>
|
||||
<TypeLibraryName>%(Filename).tlb</TypeLibraryName>
|
||||
<InterfaceIdentifierFileName>%(Filename)_i.c</InterfaceIdentifierFileName>
|
||||
<ProxyFileName>%(Filename)_p.c</ProxyFileName>
|
||||
</Midl>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
||||
<ClCompile>
|
||||
<AdditionalOptions> /Zm1000 %(AdditionalOptions)</AdditionalOptions>
|
||||
<AdditionalIncludeDirectories>C:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77/Glut;C:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77/src;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||
<CompileAs>CompileAsCpp</CompileAs>
|
||||
<EnableEnhancedInstructionSet>StreamingSIMDExtensions</EnableEnhancedInstructionSet>
|
||||
<ExceptionHandling>Sync</ExceptionHandling>
|
||||
<FloatingPointModel>Fast</FloatingPointModel>
|
||||
<InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
|
||||
<Optimization>MaxSpeed</Optimization>
|
||||
<PrecompiledHeader>NotUsing</PrecompiledHeader>
|
||||
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
|
||||
<RuntimeTypeInfo>true</RuntimeTypeInfo>
|
||||
<WarningLevel>Level3</WarningLevel>
|
||||
<DebugInformationFormat></DebugInformationFormat>
|
||||
<PreprocessorDefinitions>WIN32;NDEBUG;USE_GRAPHICAL_BENCHMARK;_IRR_STATIC_LIB_;_CRT_SECURE_NO_WARNINGS;_CRT_SECURE_NO_DEPRECATE;_SCL_SECURE_NO_WARNINGS;CMAKE_INTDIR="Release";%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
<AssemblerListingLocation>Release</AssemblerListingLocation>
|
||||
<ObjectFileName>$(IntDir)</ObjectFileName>
|
||||
<ProgramDataBaseFileName>C:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77/lib/Release/BulletSoftBody.pdb</ProgramDataBaseFileName>
|
||||
</ClCompile>
|
||||
<ResourceCompile>
|
||||
<PreprocessorDefinitions>WIN32;NDEBUG;USE_GRAPHICAL_BENCHMARK;_IRR_STATIC_LIB_;_CRT_SECURE_NO_WARNINGS;_CRT_SECURE_NO_DEPRECATE;_SCL_SECURE_NO_WARNINGS;CMAKE_INTDIR=\"Release\";%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
<AdditionalIncludeDirectories>C:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77/Glut;C:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77/src;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||
</ResourceCompile>
|
||||
<Midl>
|
||||
<AdditionalIncludeDirectories>C:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77/Glut;C:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77/src;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||
<OutputDirectory>$(IntDir)</OutputDirectory>
|
||||
<HeaderFileName>%(Filename).h</HeaderFileName>
|
||||
<TypeLibraryName>%(Filename).tlb</TypeLibraryName>
|
||||
<InterfaceIdentifierFileName>%(Filename)_i.c</InterfaceIdentifierFileName>
|
||||
<ProxyFileName>%(Filename)_p.c</ProxyFileName>
|
||||
</Midl>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='MinSizeRel|Win32'">
|
||||
<ClCompile>
|
||||
<AdditionalOptions> /Zm1000 %(AdditionalOptions)</AdditionalOptions>
|
||||
<AdditionalIncludeDirectories>C:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77/Glut;C:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77/src;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||
<CompileAs>CompileAsCpp</CompileAs>
|
||||
<EnableEnhancedInstructionSet>StreamingSIMDExtensions</EnableEnhancedInstructionSet>
|
||||
<ExceptionHandling>Sync</ExceptionHandling>
|
||||
<FloatingPointModel>Fast</FloatingPointModel>
|
||||
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
|
||||
<Optimization>MinSpace</Optimization>
|
||||
<PrecompiledHeader>NotUsing</PrecompiledHeader>
|
||||
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
|
||||
<RuntimeTypeInfo>true</RuntimeTypeInfo>
|
||||
<WarningLevel>Level3</WarningLevel>
|
||||
<DebugInformationFormat></DebugInformationFormat>
|
||||
<PreprocessorDefinitions>WIN32;NDEBUG;USE_GRAPHICAL_BENCHMARK;_IRR_STATIC_LIB_;_CRT_SECURE_NO_WARNINGS;_CRT_SECURE_NO_DEPRECATE;_SCL_SECURE_NO_WARNINGS;CMAKE_INTDIR="MinSizeRel";%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
<AssemblerListingLocation>MinSizeRel</AssemblerListingLocation>
|
||||
<ObjectFileName>$(IntDir)</ObjectFileName>
|
||||
<ProgramDataBaseFileName>C:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77/lib/MinSizeRel/BulletSoftBody.pdb</ProgramDataBaseFileName>
|
||||
</ClCompile>
|
||||
<ResourceCompile>
|
||||
<PreprocessorDefinitions>WIN32;NDEBUG;USE_GRAPHICAL_BENCHMARK;_IRR_STATIC_LIB_;_CRT_SECURE_NO_WARNINGS;_CRT_SECURE_NO_DEPRECATE;_SCL_SECURE_NO_WARNINGS;CMAKE_INTDIR=\"MinSizeRel\";%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
<AdditionalIncludeDirectories>C:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77/Glut;C:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77/src;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||
</ResourceCompile>
|
||||
<Midl>
|
||||
<AdditionalIncludeDirectories>C:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77/Glut;C:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77/src;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||
<OutputDirectory>$(IntDir)</OutputDirectory>
|
||||
<HeaderFileName>%(Filename).h</HeaderFileName>
|
||||
<TypeLibraryName>%(Filename).tlb</TypeLibraryName>
|
||||
<InterfaceIdentifierFileName>%(Filename)_i.c</InterfaceIdentifierFileName>
|
||||
<ProxyFileName>%(Filename)_p.c</ProxyFileName>
|
||||
</Midl>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='RelWithDebInfo|Win32'">
|
||||
<ClCompile>
|
||||
<AdditionalOptions> /Zm1000 %(AdditionalOptions)</AdditionalOptions>
|
||||
<AdditionalIncludeDirectories>C:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77/Glut;C:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77/src;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||
<CompileAs>CompileAsCpp</CompileAs>
|
||||
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
|
||||
<EnableEnhancedInstructionSet>StreamingSIMDExtensions</EnableEnhancedInstructionSet>
|
||||
<ExceptionHandling>Sync</ExceptionHandling>
|
||||
<FloatingPointModel>Fast</FloatingPointModel>
|
||||
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
|
||||
<Optimization>MaxSpeed</Optimization>
|
||||
<PrecompiledHeader>NotUsing</PrecompiledHeader>
|
||||
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
|
||||
<RuntimeTypeInfo>true</RuntimeTypeInfo>
|
||||
<WarningLevel>Level3</WarningLevel>
|
||||
<PreprocessorDefinitions>WIN32;NDEBUG;USE_GRAPHICAL_BENCHMARK;_IRR_STATIC_LIB_;_CRT_SECURE_NO_WARNINGS;_CRT_SECURE_NO_DEPRECATE;_SCL_SECURE_NO_WARNINGS;CMAKE_INTDIR="RelWithDebInfo";%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
<AssemblerListingLocation>RelWithDebInfo</AssemblerListingLocation>
|
||||
<ObjectFileName>$(IntDir)</ObjectFileName>
|
||||
<ProgramDataBaseFileName>C:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77/lib/RelWithDebInfo/BulletSoftBody.pdb</ProgramDataBaseFileName>
|
||||
</ClCompile>
|
||||
<ResourceCompile>
|
||||
<PreprocessorDefinitions>WIN32;NDEBUG;USE_GRAPHICAL_BENCHMARK;_IRR_STATIC_LIB_;_CRT_SECURE_NO_WARNINGS;_CRT_SECURE_NO_DEPRECATE;_SCL_SECURE_NO_WARNINGS;CMAKE_INTDIR=\"RelWithDebInfo\";%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
<AdditionalIncludeDirectories>C:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77/Glut;C:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77/src;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||
</ResourceCompile>
|
||||
<Midl>
|
||||
<AdditionalIncludeDirectories>C:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77/Glut;C:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77/src;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||
<OutputDirectory>$(IntDir)</OutputDirectory>
|
||||
<HeaderFileName>%(Filename).h</HeaderFileName>
|
||||
<TypeLibraryName>%(Filename).tlb</TypeLibraryName>
|
||||
<InterfaceIdentifierFileName>%(Filename)_i.c</InterfaceIdentifierFileName>
|
||||
<ProxyFileName>%(Filename)_p.c</ProxyFileName>
|
||||
</Midl>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemGroup>
|
||||
<CustomBuild Include="CMakeLists.txt">
|
||||
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Building Custom Rule C:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77/src/BulletSoftBody/CMakeLists.txt</Message>
|
||||
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">setlocal
|
||||
"C:\Program Files\CMake 2.8\bin\cmake.exe" "-HC:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77" "-BC:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77" --check-stamp-file "C:\Documents and Settings\Robert MacGregor\Desktop\bullet-2.77\src\BulletSoftBody\CMakeFiles\generate.stamp"
|
||||
if %errorlevel% neq 0 goto :cmEnd
|
||||
:cmEnd
|
||||
endlocal & call :cmErrorLevel %errorlevel% & goto :cmDone
|
||||
:cmErrorLevel
|
||||
exit /b %1
|
||||
:cmDone
|
||||
if %errorlevel% neq 0 goto :VCEnd</Command>
|
||||
<AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">C:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77/src/BulletSoftBody/CMakeLists.txt;C:\Documents and Settings\Robert MacGregor\Desktop\bullet-2.77\src\BulletSoftBody\CMakeLists.txt;C:\Documents and Settings\Robert MacGregor\Desktop\bullet-2.77\src\BulletSoftBody\CMakeLists.txt;%(AdditionalInputs)</AdditionalInputs>
|
||||
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">C:\Documents and Settings\Robert MacGregor\Desktop\bullet-2.77\src\BulletSoftBody\CMakeFiles\generate.stamp</Outputs>
|
||||
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Building Custom Rule C:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77/src/BulletSoftBody/CMakeLists.txt</Message>
|
||||
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">setlocal
|
||||
"C:\Program Files\CMake 2.8\bin\cmake.exe" "-HC:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77" "-BC:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77" --check-stamp-file "C:\Documents and Settings\Robert MacGregor\Desktop\bullet-2.77\src\BulletSoftBody\CMakeFiles\generate.stamp"
|
||||
if %errorlevel% neq 0 goto :cmEnd
|
||||
:cmEnd
|
||||
endlocal & call :cmErrorLevel %errorlevel% & goto :cmDone
|
||||
:cmErrorLevel
|
||||
exit /b %1
|
||||
:cmDone
|
||||
if %errorlevel% neq 0 goto :VCEnd</Command>
|
||||
<AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">C:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77/src/BulletSoftBody/CMakeLists.txt;C:\Documents and Settings\Robert MacGregor\Desktop\bullet-2.77\src\BulletSoftBody\CMakeLists.txt;C:\Documents and Settings\Robert MacGregor\Desktop\bullet-2.77\src\BulletSoftBody\CMakeLists.txt;%(AdditionalInputs)</AdditionalInputs>
|
||||
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">C:\Documents and Settings\Robert MacGregor\Desktop\bullet-2.77\src\BulletSoftBody\CMakeFiles\generate.stamp</Outputs>
|
||||
<Message Condition="'$(Configuration)|$(Platform)'=='MinSizeRel|Win32'">Building Custom Rule C:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77/src/BulletSoftBody/CMakeLists.txt</Message>
|
||||
<Command Condition="'$(Configuration)|$(Platform)'=='MinSizeRel|Win32'">setlocal
|
||||
"C:\Program Files\CMake 2.8\bin\cmake.exe" "-HC:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77" "-BC:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77" --check-stamp-file "C:\Documents and Settings\Robert MacGregor\Desktop\bullet-2.77\src\BulletSoftBody\CMakeFiles\generate.stamp"
|
||||
if %errorlevel% neq 0 goto :cmEnd
|
||||
:cmEnd
|
||||
endlocal & call :cmErrorLevel %errorlevel% & goto :cmDone
|
||||
:cmErrorLevel
|
||||
exit /b %1
|
||||
:cmDone
|
||||
if %errorlevel% neq 0 goto :VCEnd</Command>
|
||||
<AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='MinSizeRel|Win32'">C:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77/src/BulletSoftBody/CMakeLists.txt;C:\Documents and Settings\Robert MacGregor\Desktop\bullet-2.77\src\BulletSoftBody\CMakeLists.txt;C:\Documents and Settings\Robert MacGregor\Desktop\bullet-2.77\src\BulletSoftBody\CMakeLists.txt;%(AdditionalInputs)</AdditionalInputs>
|
||||
<Outputs Condition="'$(Configuration)|$(Platform)'=='MinSizeRel|Win32'">C:\Documents and Settings\Robert MacGregor\Desktop\bullet-2.77\src\BulletSoftBody\CMakeFiles\generate.stamp</Outputs>
|
||||
<Message Condition="'$(Configuration)|$(Platform)'=='RelWithDebInfo|Win32'">Building Custom Rule C:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77/src/BulletSoftBody/CMakeLists.txt</Message>
|
||||
<Command Condition="'$(Configuration)|$(Platform)'=='RelWithDebInfo|Win32'">setlocal
|
||||
"C:\Program Files\CMake 2.8\bin\cmake.exe" "-HC:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77" "-BC:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77" --check-stamp-file "C:\Documents and Settings\Robert MacGregor\Desktop\bullet-2.77\src\BulletSoftBody\CMakeFiles\generate.stamp"
|
||||
if %errorlevel% neq 0 goto :cmEnd
|
||||
:cmEnd
|
||||
endlocal & call :cmErrorLevel %errorlevel% & goto :cmDone
|
||||
:cmErrorLevel
|
||||
exit /b %1
|
||||
:cmDone
|
||||
if %errorlevel% neq 0 goto :VCEnd</Command>
|
||||
<AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='RelWithDebInfo|Win32'">C:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77/src/BulletSoftBody/CMakeLists.txt;C:\Documents and Settings\Robert MacGregor\Desktop\bullet-2.77\src\BulletSoftBody\CMakeLists.txt;C:\Documents and Settings\Robert MacGregor\Desktop\bullet-2.77\src\BulletSoftBody\CMakeLists.txt;%(AdditionalInputs)</AdditionalInputs>
|
||||
<Outputs Condition="'$(Configuration)|$(Platform)'=='RelWithDebInfo|Win32'">C:\Documents and Settings\Robert MacGregor\Desktop\bullet-2.77\src\BulletSoftBody\CMakeFiles\generate.stamp</Outputs>
|
||||
</CustomBuild>
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ClInclude Include="btSoftBody.h" />
|
||||
<ClInclude Include="btSoftBodyConcaveCollisionAlgorithm.h" />
|
||||
<ClInclude Include="btSoftBodyHelpers.h" />
|
||||
<ClInclude Include="btSoftBodyRigidBodyCollisionConfiguration.h" />
|
||||
<ClInclude Include="btSoftRigidCollisionAlgorithm.h" />
|
||||
<ClInclude Include="btSoftRigidDynamicsWorld.h" />
|
||||
<ClInclude Include="btSoftSoftCollisionAlgorithm.h" />
|
||||
<ClInclude Include="btSparseSDF.h" />
|
||||
<ClInclude Include="btSoftBodySolvers.h" />
|
||||
<ClInclude Include="btDefaultSoftBodySolver.h" />
|
||||
<ClInclude Include="btSoftBodySolverVertexBuffer.h" />
|
||||
<ClCompile Include="btSoftBody.cpp" />
|
||||
<ClCompile Include="btSoftBodyConcaveCollisionAlgorithm.cpp" />
|
||||
<ClCompile Include="btSoftBodyHelpers.cpp" />
|
||||
<ClCompile Include="btSoftBodyRigidBodyCollisionConfiguration.cpp" />
|
||||
<ClCompile Include="btSoftRigidCollisionAlgorithm.cpp" />
|
||||
<ClCompile Include="btSoftRigidDynamicsWorld.cpp" />
|
||||
<ClCompile Include="btSoftSoftCollisionAlgorithm.cpp" />
|
||||
<ClCompile Include="btDefaultSoftBodySolver.cpp" />
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ProjectReference Include="C:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77/ZERO_CHECK.vcxproj">
|
||||
<Project>C0E57694-ABCD-4C08-B9A4-F249AD836120</Project>
|
||||
</ProjectReference>
|
||||
</ItemGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
|
||||
<ImportGroup Label="ExtensionTargets">
|
||||
</ImportGroup>
|
||||
</Project>
|
||||
|
|
@ -0,0 +1,75 @@
|
|||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
|
||||
<ItemGroup>
|
||||
<ClCompile Include="btSoftBody.cpp">
|
||||
<Filter>Source Files</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="btSoftBodyConcaveCollisionAlgorithm.cpp">
|
||||
<Filter>Source Files</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="btSoftBodyHelpers.cpp">
|
||||
<Filter>Source Files</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="btSoftBodyRigidBodyCollisionConfiguration.cpp">
|
||||
<Filter>Source Files</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="btSoftRigidCollisionAlgorithm.cpp">
|
||||
<Filter>Source Files</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="btSoftRigidDynamicsWorld.cpp">
|
||||
<Filter>Source Files</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="btSoftSoftCollisionAlgorithm.cpp">
|
||||
<Filter>Source Files</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="btDefaultSoftBodySolver.cpp">
|
||||
<Filter>Source Files</Filter>
|
||||
</ClCompile>
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ClInclude Include="btSoftBody.h">
|
||||
<Filter>Header Files</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="btSoftBodyConcaveCollisionAlgorithm.h">
|
||||
<Filter>Header Files</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="btSoftBodyHelpers.h">
|
||||
<Filter>Header Files</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="btSoftBodyRigidBodyCollisionConfiguration.h">
|
||||
<Filter>Header Files</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="btSoftRigidCollisionAlgorithm.h">
|
||||
<Filter>Header Files</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="btSoftRigidDynamicsWorld.h">
|
||||
<Filter>Header Files</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="btSoftSoftCollisionAlgorithm.h">
|
||||
<Filter>Header Files</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="btSparseSDF.h">
|
||||
<Filter>Header Files</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="btSoftBodySolvers.h">
|
||||
<Filter>Header Files</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="btDefaultSoftBodySolver.h">
|
||||
<Filter>Header Files</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="btSoftBodySolverVertexBuffer.h">
|
||||
<Filter>Header Files</Filter>
|
||||
</ClInclude>
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<CustomBuild Include="CMakeLists.txt" />
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<Filter Include="Source Files">
|
||||
<UniqueIdentifier>{C487BFC5-6BC8-47B3-88D6-C5D9B883A3BD}</UniqueIdentifier>
|
||||
</Filter>
|
||||
<Filter Include="Header Files">
|
||||
<UniqueIdentifier>{30F7A2E9-D73F-45A4-9CAC-B039D62294E1}</UniqueIdentifier>
|
||||
</Filter>
|
||||
</ItemGroup>
|
||||
</Project>
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
|
||||
</Project>
|
||||
|
|
@ -0,0 +1,64 @@
|
|||
|
||||
INCLUDE_DIRECTORIES(
|
||||
${BULLET_PHYSICS_SOURCE_DIR}/src
|
||||
|
||||
)
|
||||
|
||||
#SUBDIRS( Solvers )
|
||||
|
||||
SET(BulletSoftBody_SRCS
|
||||
btSoftBody.cpp
|
||||
btSoftBodyConcaveCollisionAlgorithm.cpp
|
||||
btSoftBodyHelpers.cpp
|
||||
btSoftBodyRigidBodyCollisionConfiguration.cpp
|
||||
btSoftRigidCollisionAlgorithm.cpp
|
||||
btSoftRigidDynamicsWorld.cpp
|
||||
btSoftSoftCollisionAlgorithm.cpp
|
||||
btDefaultSoftBodySolver.cpp
|
||||
|
||||
)
|
||||
|
||||
SET(BulletSoftBody_HDRS
|
||||
btSoftBody.h
|
||||
btSoftBodyConcaveCollisionAlgorithm.h
|
||||
btSoftBodyHelpers.h
|
||||
btSoftBodyRigidBodyCollisionConfiguration.h
|
||||
btSoftRigidCollisionAlgorithm.h
|
||||
btSoftRigidDynamicsWorld.h
|
||||
btSoftSoftCollisionAlgorithm.h
|
||||
btSparseSDF.h
|
||||
|
||||
btSoftBodySolvers.h
|
||||
btDefaultSoftBodySolver.h
|
||||
|
||||
btSoftBodySolverVertexBuffer.h
|
||||
)
|
||||
|
||||
|
||||
|
||||
ADD_LIBRARY(BulletSoftBody ${BulletSoftBody_SRCS} ${BulletSoftBody_HDRS})
|
||||
SET_TARGET_PROPERTIES(BulletSoftBody PROPERTIES VERSION ${BULLET_VERSION})
|
||||
SET_TARGET_PROPERTIES(BulletSoftBody PROPERTIES SOVERSION ${BULLET_VERSION})
|
||||
IF (BUILD_SHARED_LIBS)
|
||||
TARGET_LINK_LIBRARIES(BulletSoftBody BulletDynamics)
|
||||
ENDIF (BUILD_SHARED_LIBS)
|
||||
|
||||
IF (INSTALL_LIBS)
|
||||
IF (NOT INTERNAL_CREATE_DISTRIBUTABLE_MSVC_PROJECTFILES)
|
||||
IF (${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} GREATER 2.5)
|
||||
IF (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
|
||||
INSTALL(TARGETS BulletSoftBody DESTINATION .)
|
||||
ELSE (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
|
||||
INSTALL(TARGETS BulletSoftBody 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(BulletSoftBody PROPERTIES FRAMEWORK true)
|
||||
SET_TARGET_PROPERTIES(BulletSoftBody PROPERTIES PUBLIC_HEADER "${BulletSoftBody_HDRS}")
|
||||
ENDIF (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
|
||||
ENDIF (NOT INTERNAL_CREATE_DISTRIBUTABLE_MSVC_PROJECTFILES)
|
||||
ENDIF (INSTALL_LIBS)
|
||||
|
|
@ -0,0 +1,51 @@
|
|||
/*
|
||||
Bullet Continuous Collision Detection and Physics Library
|
||||
Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/
|
||||
|
||||
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 BT_SOFT_BODY_DEFAULT_SOLVER_H
|
||||
#define BT_SOFT_BODY_DEFAULT_SOLVER_H
|
||||
|
||||
|
||||
#include "BulletSoftBody/btSoftBodySolvers.h"
|
||||
#include "btSoftBodySolverVertexBuffer.h"
|
||||
|
||||
|
||||
class btDefaultSoftBodySolver : public btSoftBodySolver
|
||||
{
|
||||
protected:
|
||||
/** Variable to define whether we need to update solver constants on the next iteration */
|
||||
bool m_updateSolverConstants;
|
||||
|
||||
btAlignedObjectArray< btSoftBody * > m_softBodySet;
|
||||
|
||||
|
||||
public:
|
||||
btDefaultSoftBodySolver();
|
||||
|
||||
virtual ~btDefaultSoftBodySolver();
|
||||
|
||||
virtual bool checkInitialized();
|
||||
|
||||
virtual void updateSoftBodies( );
|
||||
|
||||
virtual void optimize( btAlignedObjectArray< btSoftBody * > &softBodies );
|
||||
|
||||
virtual void solveConstraints( float solverdt );
|
||||
|
||||
virtual void predictMotion( float solverdt );
|
||||
|
||||
virtual void copySoftBodyToVertexBuffer( const btSoftBody *const softBody, btVertexBufferDescriptor *vertexBuffer );
|
||||
};
|
||||
|
||||
#endif // #ifndef BT_ACCELERATED_SOFT_BODY_CPU_SOLVER_H
|
||||
911
Mod Sources/Bullet/include/bullet/BulletSoftBody/btSoftBody.h
Normal file
911
Mod Sources/Bullet/include/bullet/BulletSoftBody/btSoftBody.h
Normal file
|
|
@ -0,0 +1,911 @@
|
|||
/*
|
||||
Bullet Continuous Collision Detection and Physics Library
|
||||
Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/
|
||||
|
||||
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.
|
||||
*/
|
||||
///btSoftBody implementation by Nathanael Presson
|
||||
|
||||
#ifndef _BT_SOFT_BODY_H
|
||||
#define _BT_SOFT_BODY_H
|
||||
|
||||
#include "LinearMath/btAlignedObjectArray.h"
|
||||
#include "LinearMath/btTransform.h"
|
||||
#include "LinearMath/btIDebugDraw.h"
|
||||
#include "BulletDynamics/Dynamics/btRigidBody.h"
|
||||
|
||||
#include "BulletCollision/CollisionShapes/btConcaveShape.h"
|
||||
#include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h"
|
||||
#include "btSparseSDF.h"
|
||||
#include "BulletCollision/BroadphaseCollision/btDbvt.h"
|
||||
|
||||
class btBroadphaseInterface;
|
||||
class btDispatcher;
|
||||
|
||||
|
||||
/* btSoftBodyWorldInfo */
|
||||
struct btSoftBodyWorldInfo
|
||||
{
|
||||
btScalar air_density;
|
||||
btScalar water_density;
|
||||
btScalar water_offset;
|
||||
btVector3 water_normal;
|
||||
btBroadphaseInterface* m_broadphase;
|
||||
btDispatcher* m_dispatcher;
|
||||
btVector3 m_gravity;
|
||||
btSparseSdf<3> m_sparsesdf;
|
||||
};
|
||||
|
||||
|
||||
///The btSoftBody is an class to simulate cloth and volumetric soft bodies.
|
||||
///There is two-way interaction between btSoftBody and btRigidBody/btCollisionObject.
|
||||
class btSoftBody : public btCollisionObject
|
||||
{
|
||||
public:
|
||||
btAlignedObjectArray<class btCollisionObject*> m_collisionDisabledObjects;
|
||||
|
||||
//
|
||||
// Enumerations
|
||||
//
|
||||
|
||||
///eAeroModel
|
||||
struct eAeroModel { enum _ {
|
||||
V_Point, ///Vertex normals are oriented toward velocity
|
||||
V_TwoSided, ///Vertex normals are fliped to match velocity
|
||||
V_OneSided, ///Vertex normals are taken as it is
|
||||
F_TwoSided, ///Face normals are fliped to match velocity
|
||||
F_OneSided, ///Face normals are taken as it is
|
||||
END
|
||||
};};
|
||||
|
||||
///eVSolver : velocities solvers
|
||||
struct eVSolver { enum _ {
|
||||
Linear, ///Linear solver
|
||||
END
|
||||
};};
|
||||
|
||||
///ePSolver : positions solvers
|
||||
struct ePSolver { enum _ {
|
||||
Linear, ///Linear solver
|
||||
Anchors, ///Anchor solver
|
||||
RContacts, ///Rigid contacts solver
|
||||
SContacts, ///Soft contacts solver
|
||||
END
|
||||
};};
|
||||
|
||||
///eSolverPresets
|
||||
struct eSolverPresets { enum _ {
|
||||
Positions,
|
||||
Velocities,
|
||||
Default = Positions,
|
||||
END
|
||||
};};
|
||||
|
||||
///eFeature
|
||||
struct eFeature { enum _ {
|
||||
None,
|
||||
Node,
|
||||
Link,
|
||||
Face,
|
||||
END
|
||||
};};
|
||||
|
||||
typedef btAlignedObjectArray<eVSolver::_> tVSolverArray;
|
||||
typedef btAlignedObjectArray<ePSolver::_> tPSolverArray;
|
||||
|
||||
//
|
||||
// Flags
|
||||
//
|
||||
|
||||
///fCollision
|
||||
struct fCollision { enum _ {
|
||||
RVSmask = 0x000f, ///Rigid versus soft mask
|
||||
SDF_RS = 0x0001, ///SDF based rigid vs soft
|
||||
CL_RS = 0x0002, ///Cluster vs convex rigid vs soft
|
||||
|
||||
SVSmask = 0x0030, ///Rigid versus soft mask
|
||||
VF_SS = 0x0010, ///Vertex vs face soft vs soft handling
|
||||
CL_SS = 0x0020, ///Cluster vs cluster soft vs soft handling
|
||||
CL_SELF = 0x0040, ///Cluster soft body self collision
|
||||
/* presets */
|
||||
Default = SDF_RS,
|
||||
END
|
||||
};};
|
||||
|
||||
///fMaterial
|
||||
struct fMaterial { enum _ {
|
||||
DebugDraw = 0x0001, /// Enable debug draw
|
||||
/* presets */
|
||||
Default = DebugDraw,
|
||||
END
|
||||
};};
|
||||
|
||||
//
|
||||
// API Types
|
||||
//
|
||||
|
||||
/* sRayCast */
|
||||
struct sRayCast
|
||||
{
|
||||
btSoftBody* body; /// soft body
|
||||
eFeature::_ feature; /// feature type
|
||||
int index; /// feature index
|
||||
btScalar fraction; /// time of impact fraction (rayorg+(rayto-rayfrom)*fraction)
|
||||
};
|
||||
|
||||
/* ImplicitFn */
|
||||
struct ImplicitFn
|
||||
{
|
||||
virtual btScalar Eval(const btVector3& x)=0;
|
||||
};
|
||||
|
||||
//
|
||||
// Internal types
|
||||
//
|
||||
|
||||
typedef btAlignedObjectArray<btScalar> tScalarArray;
|
||||
typedef btAlignedObjectArray<btVector3> tVector3Array;
|
||||
|
||||
/* sCti is Softbody contact info */
|
||||
struct sCti
|
||||
{
|
||||
btCollisionObject* m_colObj; /* Rigid body */
|
||||
btVector3 m_normal; /* Outward normal */
|
||||
btScalar m_offset; /* Offset from origin */
|
||||
};
|
||||
|
||||
/* sMedium */
|
||||
struct sMedium
|
||||
{
|
||||
btVector3 m_velocity; /* Velocity */
|
||||
btScalar m_pressure; /* Pressure */
|
||||
btScalar m_density; /* Density */
|
||||
};
|
||||
|
||||
/* Base type */
|
||||
struct Element
|
||||
{
|
||||
void* m_tag; // User data
|
||||
Element() : m_tag(0) {}
|
||||
};
|
||||
/* Material */
|
||||
struct Material : Element
|
||||
{
|
||||
btScalar m_kLST; // Linear stiffness coefficient [0,1]
|
||||
btScalar m_kAST; // Area/Angular stiffness coefficient [0,1]
|
||||
btScalar m_kVST; // Volume stiffness coefficient [0,1]
|
||||
int m_flags; // Flags
|
||||
};
|
||||
|
||||
/* Feature */
|
||||
struct Feature : Element
|
||||
{
|
||||
Material* m_material; // Material
|
||||
};
|
||||
/* Node */
|
||||
struct Node : Feature
|
||||
{
|
||||
btVector3 m_x; // Position
|
||||
btVector3 m_q; // Previous step position
|
||||
btVector3 m_v; // Velocity
|
||||
btVector3 m_f; // Force accumulator
|
||||
btVector3 m_n; // Normal
|
||||
btScalar m_im; // 1/mass
|
||||
btScalar m_area; // Area
|
||||
btDbvtNode* m_leaf; // Leaf data
|
||||
int m_battach:1; // Attached
|
||||
};
|
||||
/* Link */
|
||||
struct Link : Feature
|
||||
{
|
||||
Node* m_n[2]; // Node pointers
|
||||
btScalar m_rl; // Rest length
|
||||
int m_bbending:1; // Bending link
|
||||
btScalar m_c0; // (ima+imb)*kLST
|
||||
btScalar m_c1; // rl^2
|
||||
btScalar m_c2; // |gradient|^2/c0
|
||||
btVector3 m_c3; // gradient
|
||||
};
|
||||
/* Face */
|
||||
struct Face : Feature
|
||||
{
|
||||
Node* m_n[3]; // Node pointers
|
||||
btVector3 m_normal; // Normal
|
||||
btScalar m_ra; // Rest area
|
||||
btDbvtNode* m_leaf; // Leaf data
|
||||
};
|
||||
/* Tetra */
|
||||
struct Tetra : Feature
|
||||
{
|
||||
Node* m_n[4]; // Node pointers
|
||||
btScalar m_rv; // Rest volume
|
||||
btDbvtNode* m_leaf; // Leaf data
|
||||
btVector3 m_c0[4]; // gradients
|
||||
btScalar m_c1; // (4*kVST)/(im0+im1+im2+im3)
|
||||
btScalar m_c2; // m_c1/sum(|g0..3|^2)
|
||||
};
|
||||
/* RContact */
|
||||
struct RContact
|
||||
{
|
||||
sCti m_cti; // Contact infos
|
||||
Node* m_node; // Owner node
|
||||
btMatrix3x3 m_c0; // Impulse matrix
|
||||
btVector3 m_c1; // Relative anchor
|
||||
btScalar m_c2; // ima*dt
|
||||
btScalar m_c3; // Friction
|
||||
btScalar m_c4; // Hardness
|
||||
};
|
||||
/* SContact */
|
||||
struct SContact
|
||||
{
|
||||
Node* m_node; // Node
|
||||
Face* m_face; // Face
|
||||
btVector3 m_weights; // Weigths
|
||||
btVector3 m_normal; // Normal
|
||||
btScalar m_margin; // Margin
|
||||
btScalar m_friction; // Friction
|
||||
btScalar m_cfm[2]; // Constraint force mixing
|
||||
};
|
||||
/* Anchor */
|
||||
struct Anchor
|
||||
{
|
||||
Node* m_node; // Node pointer
|
||||
btVector3 m_local; // Anchor position in body space
|
||||
btRigidBody* m_body; // Body
|
||||
btMatrix3x3 m_c0; // Impulse matrix
|
||||
btVector3 m_c1; // Relative anchor
|
||||
btScalar m_c2; // ima*dt
|
||||
};
|
||||
/* Note */
|
||||
struct Note : Element
|
||||
{
|
||||
const char* m_text; // Text
|
||||
btVector3 m_offset; // Offset
|
||||
int m_rank; // Rank
|
||||
Node* m_nodes[4]; // Nodes
|
||||
btScalar m_coords[4]; // Coordinates
|
||||
};
|
||||
/* Pose */
|
||||
struct Pose
|
||||
{
|
||||
bool m_bvolume; // Is valid
|
||||
bool m_bframe; // Is frame
|
||||
btScalar m_volume; // Rest volume
|
||||
tVector3Array m_pos; // Reference positions
|
||||
tScalarArray m_wgh; // Weights
|
||||
btVector3 m_com; // COM
|
||||
btMatrix3x3 m_rot; // Rotation
|
||||
btMatrix3x3 m_scl; // Scale
|
||||
btMatrix3x3 m_aqq; // Base scaling
|
||||
};
|
||||
/* Cluster */
|
||||
struct Cluster
|
||||
{
|
||||
btAlignedObjectArray<Node*> m_nodes;
|
||||
tScalarArray m_masses;
|
||||
tVector3Array m_framerefs;
|
||||
btTransform m_framexform;
|
||||
btScalar m_idmass;
|
||||
btScalar m_imass;
|
||||
btMatrix3x3 m_locii;
|
||||
btMatrix3x3 m_invwi;
|
||||
btVector3 m_com;
|
||||
btVector3 m_vimpulses[2];
|
||||
btVector3 m_dimpulses[2];
|
||||
int m_nvimpulses;
|
||||
int m_ndimpulses;
|
||||
btVector3 m_lv;
|
||||
btVector3 m_av;
|
||||
btDbvtNode* m_leaf;
|
||||
btScalar m_ndamping; /* Node damping */
|
||||
btScalar m_ldamping; /* Linear damping */
|
||||
btScalar m_adamping; /* Angular damping */
|
||||
btScalar m_matching;
|
||||
btScalar m_maxSelfCollisionImpulse;
|
||||
btScalar m_selfCollisionImpulseFactor;
|
||||
bool m_containsAnchor;
|
||||
bool m_collide;
|
||||
int m_clusterIndex;
|
||||
Cluster() : m_leaf(0),m_ndamping(0),m_ldamping(0),m_adamping(0),m_matching(0)
|
||||
,m_maxSelfCollisionImpulse(100.f),
|
||||
m_selfCollisionImpulseFactor(0.01f),
|
||||
m_containsAnchor(false)
|
||||
{}
|
||||
};
|
||||
/* Impulse */
|
||||
struct Impulse
|
||||
{
|
||||
btVector3 m_velocity;
|
||||
btVector3 m_drift;
|
||||
int m_asVelocity:1;
|
||||
int m_asDrift:1;
|
||||
Impulse() : m_velocity(0,0,0),m_drift(0,0,0),m_asVelocity(0),m_asDrift(0) {}
|
||||
Impulse operator -() const
|
||||
{
|
||||
Impulse i=*this;
|
||||
i.m_velocity=-i.m_velocity;
|
||||
i.m_drift=-i.m_drift;
|
||||
return(i);
|
||||
}
|
||||
Impulse operator*(btScalar x) const
|
||||
{
|
||||
Impulse i=*this;
|
||||
i.m_velocity*=x;
|
||||
i.m_drift*=x;
|
||||
return(i);
|
||||
}
|
||||
};
|
||||
/* Body */
|
||||
struct Body
|
||||
{
|
||||
Cluster* m_soft;
|
||||
btRigidBody* m_rigid;
|
||||
btCollisionObject* m_collisionObject;
|
||||
|
||||
Body() : m_soft(0),m_rigid(0),m_collisionObject(0) {}
|
||||
Body(Cluster* p) : m_soft(p),m_rigid(0),m_collisionObject(0) {}
|
||||
Body(btCollisionObject* colObj) : m_soft(0),m_collisionObject(colObj)
|
||||
{
|
||||
m_rigid = btRigidBody::upcast(m_collisionObject);
|
||||
}
|
||||
|
||||
void activate() const
|
||||
{
|
||||
if(m_rigid) m_rigid->activate();
|
||||
}
|
||||
const btMatrix3x3& invWorldInertia() const
|
||||
{
|
||||
static const btMatrix3x3 iwi(0,0,0,0,0,0,0,0,0);
|
||||
if(m_rigid) return(m_rigid->getInvInertiaTensorWorld());
|
||||
if(m_soft) return(m_soft->m_invwi);
|
||||
return(iwi);
|
||||
}
|
||||
btScalar invMass() const
|
||||
{
|
||||
if(m_rigid) return(m_rigid->getInvMass());
|
||||
if(m_soft) return(m_soft->m_imass);
|
||||
return(0);
|
||||
}
|
||||
const btTransform& xform() const
|
||||
{
|
||||
static const btTransform identity=btTransform::getIdentity();
|
||||
if(m_collisionObject) return(m_collisionObject->getInterpolationWorldTransform());
|
||||
if(m_soft) return(m_soft->m_framexform);
|
||||
return(identity);
|
||||
}
|
||||
btVector3 linearVelocity() const
|
||||
{
|
||||
if(m_rigid) return(m_rigid->getLinearVelocity());
|
||||
if(m_soft) return(m_soft->m_lv);
|
||||
return(btVector3(0,0,0));
|
||||
}
|
||||
btVector3 angularVelocity(const btVector3& rpos) const
|
||||
{
|
||||
if(m_rigid) return(btCross(m_rigid->getAngularVelocity(),rpos));
|
||||
if(m_soft) return(btCross(m_soft->m_av,rpos));
|
||||
return(btVector3(0,0,0));
|
||||
}
|
||||
btVector3 angularVelocity() const
|
||||
{
|
||||
if(m_rigid) return(m_rigid->getAngularVelocity());
|
||||
if(m_soft) return(m_soft->m_av);
|
||||
return(btVector3(0,0,0));
|
||||
}
|
||||
btVector3 velocity(const btVector3& rpos) const
|
||||
{
|
||||
return(linearVelocity()+angularVelocity(rpos));
|
||||
}
|
||||
void applyVImpulse(const btVector3& impulse,const btVector3& rpos) const
|
||||
{
|
||||
if(m_rigid) m_rigid->applyImpulse(impulse,rpos);
|
||||
if(m_soft) btSoftBody::clusterVImpulse(m_soft,rpos,impulse);
|
||||
}
|
||||
void applyDImpulse(const btVector3& impulse,const btVector3& rpos) const
|
||||
{
|
||||
if(m_rigid) m_rigid->applyImpulse(impulse,rpos);
|
||||
if(m_soft) btSoftBody::clusterDImpulse(m_soft,rpos,impulse);
|
||||
}
|
||||
void applyImpulse(const Impulse& impulse,const btVector3& rpos) const
|
||||
{
|
||||
if(impulse.m_asVelocity)
|
||||
{
|
||||
// printf("impulse.m_velocity = %f,%f,%f\n",impulse.m_velocity.getX(),impulse.m_velocity.getY(),impulse.m_velocity.getZ());
|
||||
applyVImpulse(impulse.m_velocity,rpos);
|
||||
}
|
||||
if(impulse.m_asDrift)
|
||||
{
|
||||
// printf("impulse.m_drift = %f,%f,%f\n",impulse.m_drift.getX(),impulse.m_drift.getY(),impulse.m_drift.getZ());
|
||||
applyDImpulse(impulse.m_drift,rpos);
|
||||
}
|
||||
}
|
||||
void applyVAImpulse(const btVector3& impulse) const
|
||||
{
|
||||
if(m_rigid) m_rigid->applyTorqueImpulse(impulse);
|
||||
if(m_soft) btSoftBody::clusterVAImpulse(m_soft,impulse);
|
||||
}
|
||||
void applyDAImpulse(const btVector3& impulse) const
|
||||
{
|
||||
if(m_rigid) m_rigid->applyTorqueImpulse(impulse);
|
||||
if(m_soft) btSoftBody::clusterDAImpulse(m_soft,impulse);
|
||||
}
|
||||
void applyAImpulse(const Impulse& impulse) const
|
||||
{
|
||||
if(impulse.m_asVelocity) applyVAImpulse(impulse.m_velocity);
|
||||
if(impulse.m_asDrift) applyDAImpulse(impulse.m_drift);
|
||||
}
|
||||
void applyDCImpulse(const btVector3& impulse) const
|
||||
{
|
||||
if(m_rigid) m_rigid->applyCentralImpulse(impulse);
|
||||
if(m_soft) btSoftBody::clusterDCImpulse(m_soft,impulse);
|
||||
}
|
||||
};
|
||||
/* Joint */
|
||||
struct Joint
|
||||
{
|
||||
struct eType { enum _ {
|
||||
Linear,
|
||||
Angular,
|
||||
Contact
|
||||
};};
|
||||
struct Specs
|
||||
{
|
||||
Specs() : erp(1),cfm(1),split(1) {}
|
||||
btScalar erp;
|
||||
btScalar cfm;
|
||||
btScalar split;
|
||||
};
|
||||
Body m_bodies[2];
|
||||
btVector3 m_refs[2];
|
||||
btScalar m_cfm;
|
||||
btScalar m_erp;
|
||||
btScalar m_split;
|
||||
btVector3 m_drift;
|
||||
btVector3 m_sdrift;
|
||||
btMatrix3x3 m_massmatrix;
|
||||
bool m_delete;
|
||||
virtual ~Joint() {}
|
||||
Joint() : m_delete(false) {}
|
||||
virtual void Prepare(btScalar dt,int iterations);
|
||||
virtual void Solve(btScalar dt,btScalar sor)=0;
|
||||
virtual void Terminate(btScalar dt)=0;
|
||||
virtual eType::_ Type() const=0;
|
||||
};
|
||||
/* LJoint */
|
||||
struct LJoint : Joint
|
||||
{
|
||||
struct Specs : Joint::Specs
|
||||
{
|
||||
btVector3 position;
|
||||
};
|
||||
btVector3 m_rpos[2];
|
||||
void Prepare(btScalar dt,int iterations);
|
||||
void Solve(btScalar dt,btScalar sor);
|
||||
void Terminate(btScalar dt);
|
||||
eType::_ Type() const { return(eType::Linear); }
|
||||
};
|
||||
/* AJoint */
|
||||
struct AJoint : Joint
|
||||
{
|
||||
struct IControl
|
||||
{
|
||||
virtual void Prepare(AJoint*) {}
|
||||
virtual btScalar Speed(AJoint*,btScalar current) { return(current); }
|
||||
static IControl* Default() { static IControl def;return(&def); }
|
||||
};
|
||||
struct Specs : Joint::Specs
|
||||
{
|
||||
Specs() : icontrol(IControl::Default()) {}
|
||||
btVector3 axis;
|
||||
IControl* icontrol;
|
||||
};
|
||||
btVector3 m_axis[2];
|
||||
IControl* m_icontrol;
|
||||
void Prepare(btScalar dt,int iterations);
|
||||
void Solve(btScalar dt,btScalar sor);
|
||||
void Terminate(btScalar dt);
|
||||
eType::_ Type() const { return(eType::Angular); }
|
||||
};
|
||||
/* CJoint */
|
||||
struct CJoint : Joint
|
||||
{
|
||||
int m_life;
|
||||
int m_maxlife;
|
||||
btVector3 m_rpos[2];
|
||||
btVector3 m_normal;
|
||||
btScalar m_friction;
|
||||
void Prepare(btScalar dt,int iterations);
|
||||
void Solve(btScalar dt,btScalar sor);
|
||||
void Terminate(btScalar dt);
|
||||
eType::_ Type() const { return(eType::Contact); }
|
||||
};
|
||||
/* Config */
|
||||
struct Config
|
||||
{
|
||||
eAeroModel::_ aeromodel; // Aerodynamic model (default: V_Point)
|
||||
btScalar kVCF; // Velocities correction factor (Baumgarte)
|
||||
btScalar kDP; // Damping coefficient [0,1]
|
||||
btScalar kDG; // Drag coefficient [0,+inf]
|
||||
btScalar kLF; // Lift coefficient [0,+inf]
|
||||
btScalar kPR; // Pressure coefficient [-inf,+inf]
|
||||
btScalar kVC; // Volume conversation coefficient [0,+inf]
|
||||
btScalar kDF; // Dynamic friction coefficient [0,1]
|
||||
btScalar kMT; // Pose matching coefficient [0,1]
|
||||
btScalar kCHR; // Rigid contacts hardness [0,1]
|
||||
btScalar kKHR; // Kinetic contacts hardness [0,1]
|
||||
btScalar kSHR; // Soft contacts hardness [0,1]
|
||||
btScalar kAHR; // Anchors hardness [0,1]
|
||||
btScalar kSRHR_CL; // Soft vs rigid hardness [0,1] (cluster only)
|
||||
btScalar kSKHR_CL; // Soft vs kinetic hardness [0,1] (cluster only)
|
||||
btScalar kSSHR_CL; // Soft vs soft hardness [0,1] (cluster only)
|
||||
btScalar kSR_SPLT_CL; // Soft vs rigid impulse split [0,1] (cluster only)
|
||||
btScalar kSK_SPLT_CL; // Soft vs rigid impulse split [0,1] (cluster only)
|
||||
btScalar kSS_SPLT_CL; // Soft vs rigid impulse split [0,1] (cluster only)
|
||||
btScalar maxvolume; // Maximum volume ratio for pose
|
||||
btScalar timescale; // Time scale
|
||||
int viterations; // Velocities solver iterations
|
||||
int piterations; // Positions solver iterations
|
||||
int diterations; // Drift solver iterations
|
||||
int citerations; // Cluster solver iterations
|
||||
int collisions; // Collisions flags
|
||||
tVSolverArray m_vsequence; // Velocity solvers sequence
|
||||
tPSolverArray m_psequence; // Position solvers sequence
|
||||
tPSolverArray m_dsequence; // Drift solvers sequence
|
||||
};
|
||||
/* SolverState */
|
||||
struct SolverState
|
||||
{
|
||||
btScalar sdt; // dt*timescale
|
||||
btScalar isdt; // 1/sdt
|
||||
btScalar velmrg; // velocity margin
|
||||
btScalar radmrg; // radial margin
|
||||
btScalar updmrg; // Update margin
|
||||
};
|
||||
/// RayFromToCaster takes a ray from, ray to (instead of direction!)
|
||||
struct RayFromToCaster : btDbvt::ICollide
|
||||
{
|
||||
btVector3 m_rayFrom;
|
||||
btVector3 m_rayTo;
|
||||
btVector3 m_rayNormalizedDirection;
|
||||
btScalar m_mint;
|
||||
Face* m_face;
|
||||
int m_tests;
|
||||
RayFromToCaster(const btVector3& rayFrom,const btVector3& rayTo,btScalar mxt);
|
||||
void Process(const btDbvtNode* leaf);
|
||||
|
||||
static inline btScalar rayFromToTriangle(const btVector3& rayFrom,
|
||||
const btVector3& rayTo,
|
||||
const btVector3& rayNormalizedDirection,
|
||||
const btVector3& a,
|
||||
const btVector3& b,
|
||||
const btVector3& c,
|
||||
btScalar maxt=SIMD_INFINITY);
|
||||
};
|
||||
|
||||
//
|
||||
// Typedefs
|
||||
//
|
||||
|
||||
typedef void (*psolver_t)(btSoftBody*,btScalar,btScalar);
|
||||
typedef void (*vsolver_t)(btSoftBody*,btScalar);
|
||||
typedef btAlignedObjectArray<Cluster*> tClusterArray;
|
||||
typedef btAlignedObjectArray<Note> tNoteArray;
|
||||
typedef btAlignedObjectArray<Node> tNodeArray;
|
||||
typedef btAlignedObjectArray<btDbvtNode*> tLeafArray;
|
||||
typedef btAlignedObjectArray<Link> tLinkArray;
|
||||
typedef btAlignedObjectArray<Face> tFaceArray;
|
||||
typedef btAlignedObjectArray<Tetra> tTetraArray;
|
||||
typedef btAlignedObjectArray<Anchor> tAnchorArray;
|
||||
typedef btAlignedObjectArray<RContact> tRContactArray;
|
||||
typedef btAlignedObjectArray<SContact> tSContactArray;
|
||||
typedef btAlignedObjectArray<Material*> tMaterialArray;
|
||||
typedef btAlignedObjectArray<Joint*> tJointArray;
|
||||
typedef btAlignedObjectArray<btSoftBody*> tSoftBodyArray;
|
||||
|
||||
//
|
||||
// Fields
|
||||
//
|
||||
|
||||
Config m_cfg; // Configuration
|
||||
SolverState m_sst; // Solver state
|
||||
Pose m_pose; // Pose
|
||||
void* m_tag; // User data
|
||||
btSoftBodyWorldInfo* m_worldInfo; // World info
|
||||
tNoteArray m_notes; // Notes
|
||||
tNodeArray m_nodes; // Nodes
|
||||
tLinkArray m_links; // Links
|
||||
tFaceArray m_faces; // Faces
|
||||
tTetraArray m_tetras; // Tetras
|
||||
tAnchorArray m_anchors; // Anchors
|
||||
tRContactArray m_rcontacts; // Rigid contacts
|
||||
tSContactArray m_scontacts; // Soft contacts
|
||||
tJointArray m_joints; // Joints
|
||||
tMaterialArray m_materials; // Materials
|
||||
btScalar m_timeacc; // Time accumulator
|
||||
btVector3 m_bounds[2]; // Spatial bounds
|
||||
bool m_bUpdateRtCst; // Update runtime constants
|
||||
btDbvt m_ndbvt; // Nodes tree
|
||||
btDbvt m_fdbvt; // Faces tree
|
||||
btDbvt m_cdbvt; // Clusters tree
|
||||
tClusterArray m_clusters; // Clusters
|
||||
|
||||
btAlignedObjectArray<bool>m_clusterConnectivity;//cluster connectivity, for self-collision
|
||||
|
||||
btTransform m_initialWorldTransform;
|
||||
|
||||
btVector3 m_windVelocity;
|
||||
//
|
||||
// Api
|
||||
//
|
||||
|
||||
/* ctor */
|
||||
btSoftBody( btSoftBodyWorldInfo* worldInfo,int node_count,
|
||||
const btVector3* x,
|
||||
const btScalar* m);
|
||||
/* dtor */
|
||||
virtual ~btSoftBody();
|
||||
/* Check for existing link */
|
||||
|
||||
btAlignedObjectArray<int> m_userIndexMapping;
|
||||
|
||||
btSoftBodyWorldInfo* getWorldInfo()
|
||||
{
|
||||
return m_worldInfo;
|
||||
}
|
||||
|
||||
///@todo: avoid internal softbody shape hack and move collision code to collision library
|
||||
virtual void setCollisionShape(btCollisionShape* collisionShape)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
bool checkLink( int node0,
|
||||
int node1) const;
|
||||
bool checkLink( const Node* node0,
|
||||
const Node* node1) const;
|
||||
/* Check for existring face */
|
||||
bool checkFace( int node0,
|
||||
int node1,
|
||||
int node2) const;
|
||||
/* Append material */
|
||||
Material* appendMaterial();
|
||||
/* Append note */
|
||||
void appendNote( const char* text,
|
||||
const btVector3& o,
|
||||
const btVector4& c=btVector4(1,0,0,0),
|
||||
Node* n0=0,
|
||||
Node* n1=0,
|
||||
Node* n2=0,
|
||||
Node* n3=0);
|
||||
void appendNote( const char* text,
|
||||
const btVector3& o,
|
||||
Node* feature);
|
||||
void appendNote( const char* text,
|
||||
const btVector3& o,
|
||||
Link* feature);
|
||||
void appendNote( const char* text,
|
||||
const btVector3& o,
|
||||
Face* feature);
|
||||
/* Append node */
|
||||
void appendNode( const btVector3& x,btScalar m);
|
||||
/* Append link */
|
||||
void appendLink(int model=-1,Material* mat=0);
|
||||
void appendLink( int node0,
|
||||
int node1,
|
||||
Material* mat=0,
|
||||
bool bcheckexist=false);
|
||||
void appendLink( Node* node0,
|
||||
Node* node1,
|
||||
Material* mat=0,
|
||||
bool bcheckexist=false);
|
||||
/* Append face */
|
||||
void appendFace(int model=-1,Material* mat=0);
|
||||
void appendFace( int node0,
|
||||
int node1,
|
||||
int node2,
|
||||
Material* mat=0);
|
||||
void appendTetra(int model,Material* mat);
|
||||
//
|
||||
void appendTetra(int node0,
|
||||
int node1,
|
||||
int node2,
|
||||
int node3,
|
||||
Material* mat=0);
|
||||
|
||||
|
||||
/* Append anchor */
|
||||
void appendAnchor( int node,
|
||||
btRigidBody* body, bool disableCollisionBetweenLinkedBodies=false);
|
||||
/* Append linear joint */
|
||||
void appendLinearJoint(const LJoint::Specs& specs,Cluster* body0,Body body1);
|
||||
void appendLinearJoint(const LJoint::Specs& specs,Body body=Body());
|
||||
void appendLinearJoint(const LJoint::Specs& specs,btSoftBody* body);
|
||||
/* Append linear joint */
|
||||
void appendAngularJoint(const AJoint::Specs& specs,Cluster* body0,Body body1);
|
||||
void appendAngularJoint(const AJoint::Specs& specs,Body body=Body());
|
||||
void appendAngularJoint(const AJoint::Specs& specs,btSoftBody* body);
|
||||
/* Add force (or gravity) to the entire body */
|
||||
void addForce( const btVector3& force);
|
||||
/* Add force (or gravity) to a node of the body */
|
||||
void addForce( const btVector3& force,
|
||||
int node);
|
||||
/* Add velocity to the entire body */
|
||||
void addVelocity( const btVector3& velocity);
|
||||
|
||||
/* Set velocity for the entire body */
|
||||
void setVelocity( const btVector3& velocity);
|
||||
|
||||
/* Add velocity to a node of the body */
|
||||
void addVelocity( const btVector3& velocity,
|
||||
int node);
|
||||
/* Set mass */
|
||||
void setMass( int node,
|
||||
btScalar mass);
|
||||
/* Get mass */
|
||||
btScalar getMass( int node) const;
|
||||
/* Get total mass */
|
||||
btScalar getTotalMass() const;
|
||||
/* Set total mass (weighted by previous masses) */
|
||||
void setTotalMass( btScalar mass,
|
||||
bool fromfaces=false);
|
||||
/* Set total density */
|
||||
void setTotalDensity(btScalar density);
|
||||
/* Set volume mass (using tetrahedrons) */
|
||||
void setVolumeMass( btScalar mass);
|
||||
/* Set volume density (using tetrahedrons) */
|
||||
void setVolumeDensity( btScalar density);
|
||||
/* Transform */
|
||||
void transform( const btTransform& trs);
|
||||
/* Translate */
|
||||
void translate( const btVector3& trs);
|
||||
/* Rotate */
|
||||
void rotate( const btQuaternion& rot);
|
||||
/* Scale */
|
||||
void scale( const btVector3& scl);
|
||||
/* Set current state as pose */
|
||||
void setPose( bool bvolume,
|
||||
bool bframe);
|
||||
/* Return the volume */
|
||||
btScalar getVolume() const;
|
||||
/* Cluster count */
|
||||
int clusterCount() const;
|
||||
/* Cluster center of mass */
|
||||
static btVector3 clusterCom(const Cluster* cluster);
|
||||
btVector3 clusterCom(int cluster) const;
|
||||
/* Cluster velocity at rpos */
|
||||
static btVector3 clusterVelocity(const Cluster* cluster,const btVector3& rpos);
|
||||
/* Cluster impulse */
|
||||
static void clusterVImpulse(Cluster* cluster,const btVector3& rpos,const btVector3& impulse);
|
||||
static void clusterDImpulse(Cluster* cluster,const btVector3& rpos,const btVector3& impulse);
|
||||
static void clusterImpulse(Cluster* cluster,const btVector3& rpos,const Impulse& impulse);
|
||||
static void clusterVAImpulse(Cluster* cluster,const btVector3& impulse);
|
||||
static void clusterDAImpulse(Cluster* cluster,const btVector3& impulse);
|
||||
static void clusterAImpulse(Cluster* cluster,const Impulse& impulse);
|
||||
static void clusterDCImpulse(Cluster* cluster,const btVector3& impulse);
|
||||
/* Generate bending constraints based on distance in the adjency graph */
|
||||
int generateBendingConstraints( int distance,
|
||||
Material* mat=0);
|
||||
/* Randomize constraints to reduce solver bias */
|
||||
void randomizeConstraints();
|
||||
/* Release clusters */
|
||||
void releaseCluster(int index);
|
||||
void releaseClusters();
|
||||
/* Generate clusters (K-mean) */
|
||||
///generateClusters with k=0 will create a convex cluster for each tetrahedron or triangle
|
||||
///otherwise an approximation will be used (better performance)
|
||||
int generateClusters(int k,int maxiterations=8192);
|
||||
/* Refine */
|
||||
void refine(ImplicitFn* ifn,btScalar accurary,bool cut);
|
||||
/* CutLink */
|
||||
bool cutLink(int node0,int node1,btScalar position);
|
||||
bool cutLink(const Node* node0,const Node* node1,btScalar position);
|
||||
|
||||
///Ray casting using rayFrom and rayTo in worldspace, (not direction!)
|
||||
bool rayTest(const btVector3& rayFrom,
|
||||
const btVector3& rayTo,
|
||||
sRayCast& results);
|
||||
/* Solver presets */
|
||||
void setSolver(eSolverPresets::_ preset);
|
||||
/* predictMotion */
|
||||
void predictMotion(btScalar dt);
|
||||
/* solveConstraints */
|
||||
void solveConstraints();
|
||||
/* staticSolve */
|
||||
void staticSolve(int iterations);
|
||||
/* solveCommonConstraints */
|
||||
static void solveCommonConstraints(btSoftBody** bodies,int count,int iterations);
|
||||
/* solveClusters */
|
||||
static void solveClusters(const btAlignedObjectArray<btSoftBody*>& bodies);
|
||||
/* integrateMotion */
|
||||
void integrateMotion();
|
||||
/* defaultCollisionHandlers */
|
||||
void defaultCollisionHandler(btCollisionObject* pco);
|
||||
void defaultCollisionHandler(btSoftBody* psb);
|
||||
|
||||
|
||||
|
||||
//
|
||||
// Functionality to deal with new accelerated solvers.
|
||||
//
|
||||
|
||||
/**
|
||||
* Set a wind velocity for interaction with the air.
|
||||
*/
|
||||
void setWindVelocity( const btVector3 &velocity );
|
||||
|
||||
|
||||
/**
|
||||
* Return the wind velocity for interaction with the air.
|
||||
*/
|
||||
const btVector3& getWindVelocity();
|
||||
|
||||
|
||||
//
|
||||
// Cast
|
||||
//
|
||||
|
||||
static const btSoftBody* upcast(const btCollisionObject* colObj)
|
||||
{
|
||||
if (colObj->getInternalType()==CO_SOFT_BODY)
|
||||
return (const btSoftBody*)colObj;
|
||||
return 0;
|
||||
}
|
||||
static btSoftBody* upcast(btCollisionObject* colObj)
|
||||
{
|
||||
if (colObj->getInternalType()==CO_SOFT_BODY)
|
||||
return (btSoftBody*)colObj;
|
||||
return 0;
|
||||
}
|
||||
|
||||
//
|
||||
// ::btCollisionObject
|
||||
//
|
||||
|
||||
virtual void getAabb(btVector3& aabbMin,btVector3& aabbMax) const
|
||||
{
|
||||
aabbMin = m_bounds[0];
|
||||
aabbMax = m_bounds[1];
|
||||
}
|
||||
//
|
||||
// Private
|
||||
//
|
||||
void pointersToIndices();
|
||||
void indicesToPointers(const int* map=0);
|
||||
|
||||
int rayTest(const btVector3& rayFrom,const btVector3& rayTo,
|
||||
btScalar& mint,eFeature::_& feature,int& index,bool bcountonly) const;
|
||||
void initializeFaceTree();
|
||||
btVector3 evaluateCom() const;
|
||||
bool checkContact(btCollisionObject* colObj,const btVector3& x,btScalar margin,btSoftBody::sCti& cti) const;
|
||||
void updateNormals();
|
||||
void updateBounds();
|
||||
void updatePose();
|
||||
void updateConstants();
|
||||
void initializeClusters();
|
||||
void updateClusters();
|
||||
void cleanupClusters();
|
||||
void prepareClusters(int iterations);
|
||||
void solveClusters(btScalar sor);
|
||||
void applyClusters(bool drift);
|
||||
void dampClusters();
|
||||
void applyForces();
|
||||
static void PSolve_Anchors(btSoftBody* psb,btScalar kst,btScalar ti);
|
||||
static void PSolve_RContacts(btSoftBody* psb,btScalar kst,btScalar ti);
|
||||
static void PSolve_SContacts(btSoftBody* psb,btScalar,btScalar ti);
|
||||
static void PSolve_Links(btSoftBody* psb,btScalar kst,btScalar ti);
|
||||
static void VSolve_Links(btSoftBody* psb,btScalar kst);
|
||||
static psolver_t getSolver(ePSolver::_ solver);
|
||||
static vsolver_t getSolver(eVSolver::_ solver);
|
||||
|
||||
};
|
||||
|
||||
|
||||
|
||||
#endif //_BT_SOFT_BODY_H
|
||||
|
|
@ -0,0 +1,153 @@
|
|||
/*
|
||||
Bullet Continuous Collision Detection and Physics Library
|
||||
Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/
|
||||
|
||||
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 SOFT_BODY_CONCAVE_COLLISION_ALGORITHM_H
|
||||
#define SOFT_BODY_CONCAVE_COLLISION_ALGORITHM_H
|
||||
|
||||
#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
|
||||
#include "BulletCollision/BroadphaseCollision/btDispatcher.h"
|
||||
#include "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h"
|
||||
#include "BulletCollision/CollisionShapes/btTriangleCallback.h"
|
||||
#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"
|
||||
class btDispatcher;
|
||||
#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
|
||||
#include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h"
|
||||
class btSoftBody;
|
||||
class btCollisionShape;
|
||||
|
||||
#include "LinearMath/btHashMap.h"
|
||||
|
||||
#include "BulletCollision/BroadphaseCollision/btQuantizedBvh.h" //for definition of MAX_NUM_PARTS_IN_BITS
|
||||
|
||||
struct btTriIndex
|
||||
{
|
||||
int m_PartIdTriangleIndex;
|
||||
class btCollisionShape* m_childShape;
|
||||
|
||||
btTriIndex(int partId,int triangleIndex,btCollisionShape* shape)
|
||||
{
|
||||
m_PartIdTriangleIndex = (partId<<(31-MAX_NUM_PARTS_IN_BITS)) | triangleIndex;
|
||||
m_childShape = shape;
|
||||
}
|
||||
|
||||
int getTriangleIndex() const
|
||||
{
|
||||
// Get only the lower bits where the triangle index is stored
|
||||
return (m_PartIdTriangleIndex&~((~0)<<(31-MAX_NUM_PARTS_IN_BITS)));
|
||||
}
|
||||
int getPartId() const
|
||||
{
|
||||
// Get only the highest bits where the part index is stored
|
||||
return (m_PartIdTriangleIndex>>(31-MAX_NUM_PARTS_IN_BITS));
|
||||
}
|
||||
int getUid() const
|
||||
{
|
||||
return m_PartIdTriangleIndex;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
///For each triangle in the concave mesh that overlaps with the AABB of a soft body (m_softBody), processTriangle is called.
|
||||
class btSoftBodyTriangleCallback : public btTriangleCallback
|
||||
{
|
||||
btSoftBody* m_softBody;
|
||||
btCollisionObject* m_triBody;
|
||||
|
||||
btVector3 m_aabbMin;
|
||||
btVector3 m_aabbMax ;
|
||||
|
||||
btManifoldResult* m_resultOut;
|
||||
|
||||
btDispatcher* m_dispatcher;
|
||||
const btDispatcherInfo* m_dispatchInfoPtr;
|
||||
btScalar m_collisionMarginTriangle;
|
||||
|
||||
btHashMap<btHashKey<btTriIndex>,btTriIndex> m_shapeCache;
|
||||
|
||||
public:
|
||||
int m_triangleCount;
|
||||
|
||||
// btPersistentManifold* m_manifoldPtr;
|
||||
|
||||
btSoftBodyTriangleCallback(btDispatcher* dispatcher,btCollisionObject* body0,btCollisionObject* body1,bool isSwapped);
|
||||
|
||||
void setTimeStepAndCounters(btScalar collisionMarginTriangle,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
|
||||
|
||||
virtual ~btSoftBodyTriangleCallback();
|
||||
|
||||
virtual void processTriangle(btVector3* triangle, int partId, int triangleIndex);
|
||||
|
||||
void clearCache();
|
||||
|
||||
SIMD_FORCE_INLINE const btVector3& getAabbMin() const
|
||||
{
|
||||
return m_aabbMin;
|
||||
}
|
||||
SIMD_FORCE_INLINE const btVector3& getAabbMax() const
|
||||
{
|
||||
return m_aabbMax;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
/// btSoftBodyConcaveCollisionAlgorithm supports collision between soft body shapes and (concave) trianges meshes.
|
||||
class btSoftBodyConcaveCollisionAlgorithm : public btCollisionAlgorithm
|
||||
{
|
||||
|
||||
bool m_isSwapped;
|
||||
|
||||
btSoftBodyTriangleCallback m_btSoftBodyTriangleCallback;
|
||||
|
||||
public:
|
||||
|
||||
btSoftBodyConcaveCollisionAlgorithm( const btCollisionAlgorithmConstructionInfo& ci,btCollisionObject* body0,btCollisionObject* body1,bool isSwapped);
|
||||
|
||||
virtual ~btSoftBodyConcaveCollisionAlgorithm();
|
||||
|
||||
virtual void processCollision (btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
|
||||
|
||||
btScalar calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
|
||||
|
||||
virtual void getAllContactManifolds(btManifoldArray& manifoldArray)
|
||||
{
|
||||
//we don't add any manifolds
|
||||
}
|
||||
|
||||
void clearCache();
|
||||
|
||||
struct CreateFunc :public btCollisionAlgorithmCreateFunc
|
||||
{
|
||||
virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, btCollisionObject* body0,btCollisionObject* body1)
|
||||
{
|
||||
void* mem = ci.m_dispatcher1->allocateCollisionAlgorithm(sizeof(btSoftBodyConcaveCollisionAlgorithm));
|
||||
return new(mem) btSoftBodyConcaveCollisionAlgorithm(ci,body0,body1,false);
|
||||
}
|
||||
};
|
||||
|
||||
struct SwappedCreateFunc :public btCollisionAlgorithmCreateFunc
|
||||
{
|
||||
virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, btCollisionObject* body0,btCollisionObject* body1)
|
||||
{
|
||||
void* mem = ci.m_dispatcher1->allocateCollisionAlgorithm(sizeof(btSoftBodyConcaveCollisionAlgorithm));
|
||||
return new(mem) btSoftBodyConcaveCollisionAlgorithm(ci,body0,body1,true);
|
||||
}
|
||||
};
|
||||
|
||||
};
|
||||
|
||||
#endif //SOFT_BODY_CONCAVE_COLLISION_ALGORITHM_H
|
||||
|
|
@ -0,0 +1,217 @@
|
|||
/*
|
||||
Bullet Continuous Collision Detection and Physics Library
|
||||
Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/
|
||||
|
||||
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 BT_SOFTBODY_FLOAT_DATA
|
||||
#define BT_SOFTBODY_FLOAT_DATA
|
||||
|
||||
#include "BulletCollision/CollisionDispatch/btCollisionObject.h"
|
||||
#include "BulletDynamics/Dynamics/btRigidBody.h"
|
||||
|
||||
|
||||
struct SoftBodyMaterialData
|
||||
{
|
||||
float m_linearStiffness;
|
||||
float m_angularStiffness;
|
||||
float m_volumeStiffness;
|
||||
int m_flags;
|
||||
};
|
||||
|
||||
struct SoftBodyNodeData
|
||||
{
|
||||
SoftBodyMaterialData *m_material;
|
||||
btVector3FloatData m_position;
|
||||
btVector3FloatData m_previousPosition;
|
||||
btVector3FloatData m_velocity;
|
||||
btVector3FloatData m_accumulatedForce;
|
||||
btVector3FloatData m_normal;
|
||||
float m_inverseMass;
|
||||
float m_area;
|
||||
int m_attach;
|
||||
int m_pad;
|
||||
};
|
||||
|
||||
struct SoftBodyLinkData
|
||||
{
|
||||
SoftBodyMaterialData *m_material;
|
||||
int m_nodeIndices[2]; // Node pointers
|
||||
float m_restLength; // Rest length
|
||||
int m_bbending; // Bending link
|
||||
};
|
||||
|
||||
struct SoftBodyFaceData
|
||||
{
|
||||
btVector3FloatData m_normal; // Normal
|
||||
SoftBodyMaterialData *m_material;
|
||||
int m_nodeIndices[3]; // Node pointers
|
||||
float m_restArea; // Rest area
|
||||
};
|
||||
|
||||
struct SoftBodyTetraData
|
||||
{
|
||||
btVector3FloatData m_c0[4]; // gradients
|
||||
SoftBodyMaterialData *m_material;
|
||||
int m_nodeIndices[4]; // Node pointers
|
||||
float m_restVolume; // Rest volume
|
||||
float m_c1; // (4*kVST)/(im0+im1+im2+im3)
|
||||
float m_c2; // m_c1/sum(|g0..3|^2)
|
||||
int m_pad;
|
||||
};
|
||||
|
||||
struct SoftRigidAnchorData
|
||||
{
|
||||
btMatrix3x3FloatData m_c0; // Impulse matrix
|
||||
btVector3FloatData m_c1; // Relative anchor
|
||||
btVector3FloatData m_localFrame; // Anchor position in body space
|
||||
btRigidBodyData *m_rigidBody;
|
||||
int m_nodeIndex; // Node pointer
|
||||
float m_c2; // ima*dt
|
||||
};
|
||||
|
||||
|
||||
|
||||
struct SoftBodyConfigData
|
||||
{
|
||||
int m_aeroModel; // Aerodynamic model (default: V_Point)
|
||||
float m_baumgarte; // Velocities correction factor (Baumgarte)
|
||||
float m_damping; // Damping coefficient [0,1]
|
||||
float m_drag; // Drag coefficient [0,+inf]
|
||||
float m_lift; // Lift coefficient [0,+inf]
|
||||
float m_pressure; // Pressure coefficient [-inf,+inf]
|
||||
float m_volume; // Volume conversation coefficient [0,+inf]
|
||||
float m_dynamicFriction; // Dynamic friction coefficient [0,1]
|
||||
float m_poseMatch; // Pose matching coefficient [0,1]
|
||||
float m_rigidContactHardness; // Rigid contacts hardness [0,1]
|
||||
float m_kineticContactHardness; // Kinetic contacts hardness [0,1]
|
||||
float m_softContactHardness; // Soft contacts hardness [0,1]
|
||||
float m_anchorHardness; // Anchors hardness [0,1]
|
||||
float m_softRigidClusterHardness; // Soft vs rigid hardness [0,1] (cluster only)
|
||||
float m_softKineticClusterHardness; // Soft vs kinetic hardness [0,1] (cluster only)
|
||||
float m_softSoftClusterHardness; // Soft vs soft hardness [0,1] (cluster only)
|
||||
float m_softRigidClusterImpulseSplit; // Soft vs rigid impulse split [0,1] (cluster only)
|
||||
float m_softKineticClusterImpulseSplit; // Soft vs rigid impulse split [0,1] (cluster only)
|
||||
float m_softSoftClusterImpulseSplit; // Soft vs rigid impulse split [0,1] (cluster only)
|
||||
float m_maxVolume; // Maximum volume ratio for pose
|
||||
float m_timeScale; // Time scale
|
||||
int m_velocityIterations; // Velocities solver iterations
|
||||
int m_positionIterations; // Positions solver iterations
|
||||
int m_driftIterations; // Drift solver iterations
|
||||
int m_clusterIterations; // Cluster solver iterations
|
||||
int m_collisionFlags; // Collisions flags
|
||||
};
|
||||
|
||||
struct SoftBodyPoseData
|
||||
{
|
||||
btMatrix3x3FloatData m_rot; // Rotation
|
||||
btMatrix3x3FloatData m_scale; // Scale
|
||||
btMatrix3x3FloatData m_aqq; // Base scaling
|
||||
btVector3FloatData m_com; // COM
|
||||
|
||||
btVector3FloatData *m_positions; // Reference positions
|
||||
float *m_weights; // Weights
|
||||
int m_numPositions;
|
||||
int m_numWeigts;
|
||||
|
||||
int m_bvolume; // Is valid
|
||||
int m_bframe; // Is frame
|
||||
float m_restVolume; // Rest volume
|
||||
int m_pad;
|
||||
};
|
||||
|
||||
struct SoftBodyClusterData
|
||||
{
|
||||
btTransformFloatData m_framexform;
|
||||
btMatrix3x3FloatData m_locii;
|
||||
btMatrix3x3FloatData m_invwi;
|
||||
btVector3FloatData m_com;
|
||||
btVector3FloatData m_vimpulses[2];
|
||||
btVector3FloatData m_dimpulses[2];
|
||||
btVector3FloatData m_lv;
|
||||
btVector3FloatData m_av;
|
||||
|
||||
btVector3FloatData *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;
|
||||
};
|
||||
|
||||
|
||||
enum btSoftJointBodyType
|
||||
{
|
||||
BT_JOINT_SOFT_BODY_CLUSTER=1,
|
||||
BT_JOINT_RIGID_BODY,
|
||||
BT_JOINT_COLLISION_OBJECT
|
||||
};
|
||||
|
||||
struct btSoftBodyJointData
|
||||
{
|
||||
void *m_bodyA;
|
||||
void *m_bodyB;
|
||||
btVector3FloatData m_refs[2];
|
||||
float m_cfm;
|
||||
float m_erp;
|
||||
float m_split;
|
||||
int m_delete;
|
||||
btVector3FloatData m_relPosition[2];//linear
|
||||
int m_bodyAtype;
|
||||
int m_bodyBtype;
|
||||
int m_jointType;
|
||||
int m_pad;
|
||||
};
|
||||
|
||||
///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
|
||||
struct btSoftBodyFloatData
|
||||
{
|
||||
btCollisionObjectFloatData 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;
|
||||
btSoftBodyJointData *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;
|
||||
};
|
||||
|
||||
#endif //BT_SOFTBODY_FLOAT_DATA
|
||||
|
||||
|
|
@ -0,0 +1,143 @@
|
|||
/*
|
||||
Bullet Continuous Collision Detection and Physics Library
|
||||
Copyright (c) 2003-2008 Erwin Coumans http://continuousphysics.com/Bullet/
|
||||
|
||||
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 SOFT_BODY_HELPERS_H
|
||||
#define SOFT_BODY_HELPERS_H
|
||||
|
||||
#include "btSoftBody.h"
|
||||
|
||||
//
|
||||
// Helpers
|
||||
//
|
||||
|
||||
/* fDrawFlags */
|
||||
struct fDrawFlags { enum _ {
|
||||
Nodes = 0x0001,
|
||||
Links = 0x0002,
|
||||
Faces = 0x0004,
|
||||
Tetras = 0x0008,
|
||||
Normals = 0x0010,
|
||||
Contacts = 0x0020,
|
||||
Anchors = 0x0040,
|
||||
Notes = 0x0080,
|
||||
Clusters = 0x0100,
|
||||
NodeTree = 0x0200,
|
||||
FaceTree = 0x0400,
|
||||
ClusterTree = 0x0800,
|
||||
Joints = 0x1000,
|
||||
/* presets */
|
||||
Std = Links+Faces+Tetras+Anchors+Notes+Joints,
|
||||
StdTetra = Std-Faces+Tetras
|
||||
};};
|
||||
|
||||
struct btSoftBodyHelpers
|
||||
{
|
||||
/* Draw body */
|
||||
static void Draw( btSoftBody* psb,
|
||||
btIDebugDraw* idraw,
|
||||
int drawflags=fDrawFlags::Std);
|
||||
/* Draw body infos */
|
||||
static void DrawInfos( btSoftBody* psb,
|
||||
btIDebugDraw* idraw,
|
||||
bool masses,
|
||||
bool areas,
|
||||
bool stress);
|
||||
/* Draw node tree */
|
||||
static void DrawNodeTree( btSoftBody* psb,
|
||||
btIDebugDraw* idraw,
|
||||
int mindepth=0,
|
||||
int maxdepth=-1);
|
||||
/* Draw face tree */
|
||||
static void DrawFaceTree( btSoftBody* psb,
|
||||
btIDebugDraw* idraw,
|
||||
int mindepth=0,
|
||||
int maxdepth=-1);
|
||||
/* Draw cluster tree */
|
||||
static void DrawClusterTree(btSoftBody* psb,
|
||||
btIDebugDraw* idraw,
|
||||
int mindepth=0,
|
||||
int maxdepth=-1);
|
||||
/* Draw rigid frame */
|
||||
static void DrawFrame( btSoftBody* psb,
|
||||
btIDebugDraw* idraw);
|
||||
/* Create a rope */
|
||||
static btSoftBody* CreateRope( btSoftBodyWorldInfo& worldInfo,
|
||||
const btVector3& from,
|
||||
const btVector3& to,
|
||||
int res,
|
||||
int fixeds);
|
||||
/* Create a patch */
|
||||
static btSoftBody* CreatePatch(btSoftBodyWorldInfo& worldInfo,
|
||||
const btVector3& corner00,
|
||||
const btVector3& corner10,
|
||||
const btVector3& corner01,
|
||||
const btVector3& corner11,
|
||||
int resx,
|
||||
int resy,
|
||||
int fixeds,
|
||||
bool gendiags);
|
||||
/* Create a patch with UV Texture Coordinates */
|
||||
static btSoftBody* CreatePatchUV(btSoftBodyWorldInfo& worldInfo,
|
||||
const btVector3& corner00,
|
||||
const btVector3& corner10,
|
||||
const btVector3& corner01,
|
||||
const btVector3& corner11,
|
||||
int resx,
|
||||
int resy,
|
||||
int fixeds,
|
||||
bool gendiags,
|
||||
float* tex_coords=0);
|
||||
static float CalculateUV(int resx,int resy,int ix,int iy,int id);
|
||||
/* Create an ellipsoid */
|
||||
static btSoftBody* CreateEllipsoid(btSoftBodyWorldInfo& worldInfo,
|
||||
const btVector3& center,
|
||||
const btVector3& radius,
|
||||
int res);
|
||||
/* Create from trimesh */
|
||||
static btSoftBody* CreateFromTriMesh( btSoftBodyWorldInfo& worldInfo,
|
||||
const btScalar* vertices,
|
||||
const int* triangles,
|
||||
int ntriangles,
|
||||
bool randomizeConstraints = true);
|
||||
/* Create from convex-hull */
|
||||
static btSoftBody* CreateFromConvexHull( btSoftBodyWorldInfo& worldInfo,
|
||||
const btVector3* vertices,
|
||||
int nvertices,
|
||||
bool randomizeConstraints = true);
|
||||
|
||||
|
||||
/* Export TetGen compatible .smesh file */
|
||||
static void ExportAsSMeshFile( btSoftBody* psb,
|
||||
const char* filename);
|
||||
/* Create from TetGen .ele, .face, .node files */
|
||||
static btSoftBody* CreateFromTetGenFile( btSoftBodyWorldInfo& worldInfo,
|
||||
const char* ele,
|
||||
const char* face,
|
||||
const char* node,
|
||||
bool bfacelinks,
|
||||
bool btetralinks,
|
||||
bool bfacesfromtetras);
|
||||
/* Create from TetGen .ele, .face, .node data */
|
||||
static btSoftBody* CreateFromTetGenData( btSoftBodyWorldInfo& worldInfo,
|
||||
const char* ele,
|
||||
const char* face,
|
||||
const char* node,
|
||||
bool bfacelinks,
|
||||
bool btetralinks,
|
||||
bool bfacesfromtetras);
|
||||
|
||||
};
|
||||
|
||||
#endif //SOFT_BODY_HELPERS_H
|
||||
|
|
@ -0,0 +1,931 @@
|
|||
/*
|
||||
Bullet Continuous Collision Detection and Physics Library
|
||||
Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/
|
||||
|
||||
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.
|
||||
*/
|
||||
///btSoftBody implementation by Nathanael Presson
|
||||
|
||||
#ifndef _BT_SOFT_BODY_INTERNALS_H
|
||||
#define _BT_SOFT_BODY_INTERNALS_H
|
||||
|
||||
#include "btSoftBody.h"
|
||||
|
||||
|
||||
#include "LinearMath/btQuickprof.h"
|
||||
#include "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h"
|
||||
#include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h"
|
||||
#include "BulletCollision/CollisionShapes/btConvexInternalShape.h"
|
||||
#include "BulletCollision/NarrowPhaseCollision/btGjkEpa2.h"
|
||||
|
||||
//
|
||||
// btSymMatrix
|
||||
//
|
||||
template <typename T>
|
||||
struct btSymMatrix
|
||||
{
|
||||
btSymMatrix() : dim(0) {}
|
||||
btSymMatrix(int n,const T& init=T()) { resize(n,init); }
|
||||
void resize(int n,const T& init=T()) { dim=n;store.resize((n*(n+1))/2,init); }
|
||||
int index(int c,int r) const { if(c>r) btSwap(c,r);btAssert(r<dim);return((r*(r+1))/2+c); }
|
||||
T& operator()(int c,int r) { return(store[index(c,r)]); }
|
||||
const T& operator()(int c,int r) const { return(store[index(c,r)]); }
|
||||
btAlignedObjectArray<T> store;
|
||||
int dim;
|
||||
};
|
||||
|
||||
//
|
||||
// btSoftBodyCollisionShape
|
||||
//
|
||||
class btSoftBodyCollisionShape : public btConcaveShape
|
||||
{
|
||||
public:
|
||||
btSoftBody* m_body;
|
||||
|
||||
btSoftBodyCollisionShape(btSoftBody* backptr)
|
||||
{
|
||||
m_shapeType = SOFTBODY_SHAPE_PROXYTYPE;
|
||||
m_body=backptr;
|
||||
}
|
||||
|
||||
virtual ~btSoftBodyCollisionShape()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void processAllTriangles(btTriangleCallback* /*callback*/,const btVector3& /*aabbMin*/,const btVector3& /*aabbMax*/) const
|
||||
{
|
||||
//not yet
|
||||
btAssert(0);
|
||||
}
|
||||
|
||||
///getAabb returns the axis aligned bounding box in the coordinate frame of the given transform t.
|
||||
virtual void getAabb(const btTransform& t,btVector3& aabbMin,btVector3& aabbMax) const
|
||||
{
|
||||
/* t should be identity, but better be safe than...fast? */
|
||||
const btVector3 mins=m_body->m_bounds[0];
|
||||
const btVector3 maxs=m_body->m_bounds[1];
|
||||
const btVector3 crns[]={t*btVector3(mins.x(),mins.y(),mins.z()),
|
||||
t*btVector3(maxs.x(),mins.y(),mins.z()),
|
||||
t*btVector3(maxs.x(),maxs.y(),mins.z()),
|
||||
t*btVector3(mins.x(),maxs.y(),mins.z()),
|
||||
t*btVector3(mins.x(),mins.y(),maxs.z()),
|
||||
t*btVector3(maxs.x(),mins.y(),maxs.z()),
|
||||
t*btVector3(maxs.x(),maxs.y(),maxs.z()),
|
||||
t*btVector3(mins.x(),maxs.y(),maxs.z())};
|
||||
aabbMin=aabbMax=crns[0];
|
||||
for(int i=1;i<8;++i)
|
||||
{
|
||||
aabbMin.setMin(crns[i]);
|
||||
aabbMax.setMax(crns[i]);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
virtual void setLocalScaling(const btVector3& /*scaling*/)
|
||||
{
|
||||
///na
|
||||
}
|
||||
virtual const btVector3& getLocalScaling() const
|
||||
{
|
||||
static const btVector3 dummy(1,1,1);
|
||||
return dummy;
|
||||
}
|
||||
virtual void calculateLocalInertia(btScalar /*mass*/,btVector3& /*inertia*/) const
|
||||
{
|
||||
///not yet
|
||||
btAssert(0);
|
||||
}
|
||||
virtual const char* getName()const
|
||||
{
|
||||
return "SoftBody";
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
//
|
||||
// btSoftClusterCollisionShape
|
||||
//
|
||||
class btSoftClusterCollisionShape : public btConvexInternalShape
|
||||
{
|
||||
public:
|
||||
const btSoftBody::Cluster* m_cluster;
|
||||
|
||||
btSoftClusterCollisionShape (const btSoftBody::Cluster* cluster) : m_cluster(cluster) { setMargin(0); }
|
||||
|
||||
|
||||
virtual btVector3 localGetSupportingVertex(const btVector3& vec) const
|
||||
{
|
||||
btSoftBody::Node* const * n=&m_cluster->m_nodes[0];
|
||||
btScalar d=btDot(vec,n[0]->m_x);
|
||||
int j=0;
|
||||
for(int i=1,ni=m_cluster->m_nodes.size();i<ni;++i)
|
||||
{
|
||||
const btScalar k=btDot(vec,n[i]->m_x);
|
||||
if(k>d) { d=k;j=i; }
|
||||
}
|
||||
return(n[j]->m_x);
|
||||
}
|
||||
virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3& vec)const
|
||||
{
|
||||
return(localGetSupportingVertex(vec));
|
||||
}
|
||||
//notice that the vectors should be unit length
|
||||
virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const
|
||||
{}
|
||||
|
||||
|
||||
virtual void calculateLocalInertia(btScalar mass,btVector3& inertia) const
|
||||
{}
|
||||
|
||||
virtual void getAabb(const btTransform& t,btVector3& aabbMin,btVector3& aabbMax) const
|
||||
{}
|
||||
|
||||
virtual int getShapeType() const { return SOFTBODY_SHAPE_PROXYTYPE; }
|
||||
|
||||
//debugging
|
||||
virtual const char* getName()const {return "SOFTCLUSTER";}
|
||||
|
||||
virtual void setMargin(btScalar margin)
|
||||
{
|
||||
btConvexInternalShape::setMargin(margin);
|
||||
}
|
||||
virtual btScalar getMargin() const
|
||||
{
|
||||
return getMargin();
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// Inline's
|
||||
//
|
||||
|
||||
//
|
||||
template <typename T>
|
||||
static inline void ZeroInitialize(T& value)
|
||||
{
|
||||
static const T zerodummy;
|
||||
value=zerodummy;
|
||||
}
|
||||
//
|
||||
template <typename T>
|
||||
static inline bool CompLess(const T& a,const T& b)
|
||||
{ return(a<b); }
|
||||
//
|
||||
template <typename T>
|
||||
static inline bool CompGreater(const T& a,const T& b)
|
||||
{ return(a>b); }
|
||||
//
|
||||
template <typename T>
|
||||
static inline T Lerp(const T& a,const T& b,btScalar t)
|
||||
{ return(a+(b-a)*t); }
|
||||
//
|
||||
template <typename T>
|
||||
static inline T InvLerp(const T& a,const T& b,btScalar t)
|
||||
{ return((b+a*t-b*t)/(a*b)); }
|
||||
//
|
||||
static inline btMatrix3x3 Lerp( const btMatrix3x3& a,
|
||||
const btMatrix3x3& b,
|
||||
btScalar t)
|
||||
{
|
||||
btMatrix3x3 r;
|
||||
r[0]=Lerp(a[0],b[0],t);
|
||||
r[1]=Lerp(a[1],b[1],t);
|
||||
r[2]=Lerp(a[2],b[2],t);
|
||||
return(r);
|
||||
}
|
||||
//
|
||||
static inline btVector3 Clamp(const btVector3& v,btScalar maxlength)
|
||||
{
|
||||
const btScalar sql=v.length2();
|
||||
if(sql>(maxlength*maxlength))
|
||||
return((v*maxlength)/btSqrt(sql));
|
||||
else
|
||||
return(v);
|
||||
}
|
||||
//
|
||||
template <typename T>
|
||||
static inline T Clamp(const T& x,const T& l,const T& h)
|
||||
{ return(x<l?l:x>h?h:x); }
|
||||
//
|
||||
template <typename T>
|
||||
static inline T Sq(const T& x)
|
||||
{ return(x*x); }
|
||||
//
|
||||
template <typename T>
|
||||
static inline T Cube(const T& x)
|
||||
{ return(x*x*x); }
|
||||
//
|
||||
template <typename T>
|
||||
static inline T Sign(const T& x)
|
||||
{ return((T)(x<0?-1:+1)); }
|
||||
//
|
||||
template <typename T>
|
||||
static inline bool SameSign(const T& x,const T& y)
|
||||
{ return((x*y)>0); }
|
||||
//
|
||||
static inline btScalar ClusterMetric(const btVector3& x,const btVector3& y)
|
||||
{
|
||||
const btVector3 d=x-y;
|
||||
return(btFabs(d[0])+btFabs(d[1])+btFabs(d[2]));
|
||||
}
|
||||
//
|
||||
static inline btMatrix3x3 ScaleAlongAxis(const btVector3& a,btScalar s)
|
||||
{
|
||||
const btScalar xx=a.x()*a.x();
|
||||
const btScalar yy=a.y()*a.y();
|
||||
const btScalar zz=a.z()*a.z();
|
||||
const btScalar xy=a.x()*a.y();
|
||||
const btScalar yz=a.y()*a.z();
|
||||
const btScalar zx=a.z()*a.x();
|
||||
btMatrix3x3 m;
|
||||
m[0]=btVector3(1-xx+xx*s,xy*s-xy,zx*s-zx);
|
||||
m[1]=btVector3(xy*s-xy,1-yy+yy*s,yz*s-yz);
|
||||
m[2]=btVector3(zx*s-zx,yz*s-yz,1-zz+zz*s);
|
||||
return(m);
|
||||
}
|
||||
//
|
||||
static inline btMatrix3x3 Cross(const btVector3& v)
|
||||
{
|
||||
btMatrix3x3 m;
|
||||
m[0]=btVector3(0,-v.z(),+v.y());
|
||||
m[1]=btVector3(+v.z(),0,-v.x());
|
||||
m[2]=btVector3(-v.y(),+v.x(),0);
|
||||
return(m);
|
||||
}
|
||||
//
|
||||
static inline btMatrix3x3 Diagonal(btScalar x)
|
||||
{
|
||||
btMatrix3x3 m;
|
||||
m[0]=btVector3(x,0,0);
|
||||
m[1]=btVector3(0,x,0);
|
||||
m[2]=btVector3(0,0,x);
|
||||
return(m);
|
||||
}
|
||||
//
|
||||
static inline btMatrix3x3 Add(const btMatrix3x3& a,
|
||||
const btMatrix3x3& b)
|
||||
{
|
||||
btMatrix3x3 r;
|
||||
for(int i=0;i<3;++i) r[i]=a[i]+b[i];
|
||||
return(r);
|
||||
}
|
||||
//
|
||||
static inline btMatrix3x3 Sub(const btMatrix3x3& a,
|
||||
const btMatrix3x3& b)
|
||||
{
|
||||
btMatrix3x3 r;
|
||||
for(int i=0;i<3;++i) r[i]=a[i]-b[i];
|
||||
return(r);
|
||||
}
|
||||
//
|
||||
static inline btMatrix3x3 Mul(const btMatrix3x3& a,
|
||||
btScalar b)
|
||||
{
|
||||
btMatrix3x3 r;
|
||||
for(int i=0;i<3;++i) r[i]=a[i]*b;
|
||||
return(r);
|
||||
}
|
||||
//
|
||||
static inline void Orthogonalize(btMatrix3x3& m)
|
||||
{
|
||||
m[2]=btCross(m[0],m[1]).normalized();
|
||||
m[1]=btCross(m[2],m[0]).normalized();
|
||||
m[0]=btCross(m[1],m[2]).normalized();
|
||||
}
|
||||
//
|
||||
static inline btMatrix3x3 MassMatrix(btScalar im,const btMatrix3x3& iwi,const btVector3& r)
|
||||
{
|
||||
const btMatrix3x3 cr=Cross(r);
|
||||
return(Sub(Diagonal(im),cr*iwi*cr));
|
||||
}
|
||||
|
||||
//
|
||||
static inline btMatrix3x3 ImpulseMatrix( btScalar dt,
|
||||
btScalar ima,
|
||||
btScalar imb,
|
||||
const btMatrix3x3& iwi,
|
||||
const btVector3& r)
|
||||
{
|
||||
return(Diagonal(1/dt)*Add(Diagonal(ima),MassMatrix(imb,iwi,r)).inverse());
|
||||
}
|
||||
|
||||
//
|
||||
static inline btMatrix3x3 ImpulseMatrix( btScalar ima,const btMatrix3x3& iia,const btVector3& ra,
|
||||
btScalar imb,const btMatrix3x3& iib,const btVector3& rb)
|
||||
{
|
||||
return(Add(MassMatrix(ima,iia,ra),MassMatrix(imb,iib,rb)).inverse());
|
||||
}
|
||||
|
||||
//
|
||||
static inline btMatrix3x3 AngularImpulseMatrix( const btMatrix3x3& iia,
|
||||
const btMatrix3x3& iib)
|
||||
{
|
||||
return(Add(iia,iib).inverse());
|
||||
}
|
||||
|
||||
//
|
||||
static inline btVector3 ProjectOnAxis( const btVector3& v,
|
||||
const btVector3& a)
|
||||
{
|
||||
return(a*btDot(v,a));
|
||||
}
|
||||
//
|
||||
static inline btVector3 ProjectOnPlane( const btVector3& v,
|
||||
const btVector3& a)
|
||||
{
|
||||
return(v-ProjectOnAxis(v,a));
|
||||
}
|
||||
|
||||
//
|
||||
static inline void ProjectOrigin( const btVector3& a,
|
||||
const btVector3& b,
|
||||
btVector3& prj,
|
||||
btScalar& sqd)
|
||||
{
|
||||
const btVector3 d=b-a;
|
||||
const btScalar m2=d.length2();
|
||||
if(m2>SIMD_EPSILON)
|
||||
{
|
||||
const btScalar t=Clamp<btScalar>(-btDot(a,d)/m2,0,1);
|
||||
const btVector3 p=a+d*t;
|
||||
const btScalar l2=p.length2();
|
||||
if(l2<sqd)
|
||||
{
|
||||
prj=p;
|
||||
sqd=l2;
|
||||
}
|
||||
}
|
||||
}
|
||||
//
|
||||
static inline void ProjectOrigin( const btVector3& a,
|
||||
const btVector3& b,
|
||||
const btVector3& c,
|
||||
btVector3& prj,
|
||||
btScalar& sqd)
|
||||
{
|
||||
const btVector3& q=btCross(b-a,c-a);
|
||||
const btScalar m2=q.length2();
|
||||
if(m2>SIMD_EPSILON)
|
||||
{
|
||||
const btVector3 n=q/btSqrt(m2);
|
||||
const btScalar k=btDot(a,n);
|
||||
const btScalar k2=k*k;
|
||||
if(k2<sqd)
|
||||
{
|
||||
const btVector3 p=n*k;
|
||||
if( (btDot(btCross(a-p,b-p),q)>0)&&
|
||||
(btDot(btCross(b-p,c-p),q)>0)&&
|
||||
(btDot(btCross(c-p,a-p),q)>0))
|
||||
{
|
||||
prj=p;
|
||||
sqd=k2;
|
||||
}
|
||||
else
|
||||
{
|
||||
ProjectOrigin(a,b,prj,sqd);
|
||||
ProjectOrigin(b,c,prj,sqd);
|
||||
ProjectOrigin(c,a,prj,sqd);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
template <typename T>
|
||||
static inline T BaryEval( const T& a,
|
||||
const T& b,
|
||||
const T& c,
|
||||
const btVector3& coord)
|
||||
{
|
||||
return(a*coord.x()+b*coord.y()+c*coord.z());
|
||||
}
|
||||
//
|
||||
static inline btVector3 BaryCoord( const btVector3& a,
|
||||
const btVector3& b,
|
||||
const btVector3& c,
|
||||
const btVector3& p)
|
||||
{
|
||||
const btScalar w[]={ btCross(a-p,b-p).length(),
|
||||
btCross(b-p,c-p).length(),
|
||||
btCross(c-p,a-p).length()};
|
||||
const btScalar isum=1/(w[0]+w[1]+w[2]);
|
||||
return(btVector3(w[1]*isum,w[2]*isum,w[0]*isum));
|
||||
}
|
||||
|
||||
//
|
||||
static btScalar ImplicitSolve( btSoftBody::ImplicitFn* fn,
|
||||
const btVector3& a,
|
||||
const btVector3& b,
|
||||
const btScalar accuracy,
|
||||
const int maxiterations=256)
|
||||
{
|
||||
btScalar span[2]={0,1};
|
||||
btScalar values[2]={fn->Eval(a),fn->Eval(b)};
|
||||
if(values[0]>values[1])
|
||||
{
|
||||
btSwap(span[0],span[1]);
|
||||
btSwap(values[0],values[1]);
|
||||
}
|
||||
if(values[0]>-accuracy) return(-1);
|
||||
if(values[1]<+accuracy) return(-1);
|
||||
for(int i=0;i<maxiterations;++i)
|
||||
{
|
||||
const btScalar t=Lerp(span[0],span[1],values[0]/(values[0]-values[1]));
|
||||
const btScalar v=fn->Eval(Lerp(a,b,t));
|
||||
if((t<=0)||(t>=1)) break;
|
||||
if(btFabs(v)<accuracy) return(t);
|
||||
if(v<0)
|
||||
{ span[0]=t;values[0]=v; }
|
||||
else
|
||||
{ span[1]=t;values[1]=v; }
|
||||
}
|
||||
return(-1);
|
||||
}
|
||||
|
||||
//
|
||||
static inline btVector3 NormalizeAny(const btVector3& v)
|
||||
{
|
||||
const btScalar l=v.length();
|
||||
if(l>SIMD_EPSILON)
|
||||
return(v/l);
|
||||
else
|
||||
return(btVector3(0,0,0));
|
||||
}
|
||||
|
||||
//
|
||||
static inline btDbvtVolume VolumeOf( const btSoftBody::Face& f,
|
||||
btScalar margin)
|
||||
{
|
||||
const btVector3* pts[]={ &f.m_n[0]->m_x,
|
||||
&f.m_n[1]->m_x,
|
||||
&f.m_n[2]->m_x};
|
||||
btDbvtVolume vol=btDbvtVolume::FromPoints(pts,3);
|
||||
vol.Expand(btVector3(margin,margin,margin));
|
||||
return(vol);
|
||||
}
|
||||
|
||||
//
|
||||
static inline btVector3 CenterOf( const btSoftBody::Face& f)
|
||||
{
|
||||
return((f.m_n[0]->m_x+f.m_n[1]->m_x+f.m_n[2]->m_x)/3);
|
||||
}
|
||||
|
||||
//
|
||||
static inline btScalar AreaOf( const btVector3& x0,
|
||||
const btVector3& x1,
|
||||
const btVector3& x2)
|
||||
{
|
||||
const btVector3 a=x1-x0;
|
||||
const btVector3 b=x2-x0;
|
||||
const btVector3 cr=btCross(a,b);
|
||||
const btScalar area=cr.length();
|
||||
return(area);
|
||||
}
|
||||
|
||||
//
|
||||
static inline btScalar VolumeOf( const btVector3& x0,
|
||||
const btVector3& x1,
|
||||
const btVector3& x2,
|
||||
const btVector3& x3)
|
||||
{
|
||||
const btVector3 a=x1-x0;
|
||||
const btVector3 b=x2-x0;
|
||||
const btVector3 c=x3-x0;
|
||||
return(btDot(a,btCross(b,c)));
|
||||
}
|
||||
|
||||
//
|
||||
static void EvaluateMedium( const btSoftBodyWorldInfo* wfi,
|
||||
const btVector3& x,
|
||||
btSoftBody::sMedium& medium)
|
||||
{
|
||||
medium.m_velocity = btVector3(0,0,0);
|
||||
medium.m_pressure = 0;
|
||||
medium.m_density = wfi->air_density;
|
||||
if(wfi->water_density>0)
|
||||
{
|
||||
const btScalar depth=-(btDot(x,wfi->water_normal)+wfi->water_offset);
|
||||
if(depth>0)
|
||||
{
|
||||
medium.m_density = wfi->water_density;
|
||||
medium.m_pressure = depth*wfi->water_density*wfi->m_gravity.length();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
static inline void ApplyClampedForce( btSoftBody::Node& n,
|
||||
const btVector3& f,
|
||||
btScalar dt)
|
||||
{
|
||||
const btScalar dtim=dt*n.m_im;
|
||||
if((f*dtim).length2()>n.m_v.length2())
|
||||
{/* Clamp */
|
||||
n.m_f-=ProjectOnAxis(n.m_v,f.normalized())/dtim;
|
||||
}
|
||||
else
|
||||
{/* Apply */
|
||||
n.m_f+=f;
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
static inline int MatchEdge( const btSoftBody::Node* a,
|
||||
const btSoftBody::Node* b,
|
||||
const btSoftBody::Node* ma,
|
||||
const btSoftBody::Node* mb)
|
||||
{
|
||||
if((a==ma)&&(b==mb)) return(0);
|
||||
if((a==mb)&&(b==ma)) return(1);
|
||||
return(-1);
|
||||
}
|
||||
|
||||
//
|
||||
// btEigen : Extract eigen system,
|
||||
// straitforward implementation of http://math.fullerton.edu/mathews/n2003/JacobiMethodMod.html
|
||||
// outputs are NOT sorted.
|
||||
//
|
||||
struct btEigen
|
||||
{
|
||||
static int system(btMatrix3x3& a,btMatrix3x3* vectors,btVector3* values=0)
|
||||
{
|
||||
static const int maxiterations=16;
|
||||
static const btScalar accuracy=(btScalar)0.0001;
|
||||
btMatrix3x3& v=*vectors;
|
||||
int iterations=0;
|
||||
vectors->setIdentity();
|
||||
do {
|
||||
int p=0,q=1;
|
||||
if(btFabs(a[p][q])<btFabs(a[0][2])) { p=0;q=2; }
|
||||
if(btFabs(a[p][q])<btFabs(a[1][2])) { p=1;q=2; }
|
||||
if(btFabs(a[p][q])>accuracy)
|
||||
{
|
||||
const btScalar w=(a[q][q]-a[p][p])/(2*a[p][q]);
|
||||
const btScalar z=btFabs(w);
|
||||
const btScalar t=w/(z*(btSqrt(1+w*w)+z));
|
||||
if(t==t)/* [WARNING] let hope that one does not get thrown aways by some compilers... */
|
||||
{
|
||||
const btScalar c=1/btSqrt(t*t+1);
|
||||
const btScalar s=c*t;
|
||||
mulPQ(a,c,s,p,q);
|
||||
mulTPQ(a,c,s,p,q);
|
||||
mulPQ(v,c,s,p,q);
|
||||
} else break;
|
||||
} else break;
|
||||
} while((++iterations)<maxiterations);
|
||||
if(values)
|
||||
{
|
||||
*values=btVector3(a[0][0],a[1][1],a[2][2]);
|
||||
}
|
||||
return(iterations);
|
||||
}
|
||||
private:
|
||||
static inline void mulTPQ(btMatrix3x3& a,btScalar c,btScalar s,int p,int q)
|
||||
{
|
||||
const btScalar m[2][3]={ {a[p][0],a[p][1],a[p][2]},
|
||||
{a[q][0],a[q][1],a[q][2]}};
|
||||
int i;
|
||||
|
||||
for(i=0;i<3;++i) a[p][i]=c*m[0][i]-s*m[1][i];
|
||||
for(i=0;i<3;++i) a[q][i]=c*m[1][i]+s*m[0][i];
|
||||
}
|
||||
static inline void mulPQ(btMatrix3x3& a,btScalar c,btScalar s,int p,int q)
|
||||
{
|
||||
const btScalar m[2][3]={ {a[0][p],a[1][p],a[2][p]},
|
||||
{a[0][q],a[1][q],a[2][q]}};
|
||||
int i;
|
||||
|
||||
for(i=0;i<3;++i) a[i][p]=c*m[0][i]-s*m[1][i];
|
||||
for(i=0;i<3;++i) a[i][q]=c*m[1][i]+s*m[0][i];
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// Polar decomposition,
|
||||
// "Computing the Polar Decomposition with Applications", Nicholas J. Higham, 1986.
|
||||
//
|
||||
static inline int PolarDecompose( const btMatrix3x3& m,btMatrix3x3& q,btMatrix3x3& s)
|
||||
{
|
||||
static const btScalar half=(btScalar)0.5;
|
||||
static const btScalar accuracy=(btScalar)0.0001;
|
||||
static const int maxiterations=16;
|
||||
int i=0;
|
||||
btScalar det=0;
|
||||
q = Mul(m,1/btVector3(m[0][0],m[1][1],m[2][2]).length());
|
||||
det = q.determinant();
|
||||
if(!btFuzzyZero(det))
|
||||
{
|
||||
for(;i<maxiterations;++i)
|
||||
{
|
||||
q=Mul(Add(q,Mul(q.adjoint(),1/det).transpose()),half);
|
||||
const btScalar ndet=q.determinant();
|
||||
if(Sq(ndet-det)>accuracy) det=ndet; else break;
|
||||
}
|
||||
/* Final orthogonalization */
|
||||
Orthogonalize(q);
|
||||
/* Compute 'S' */
|
||||
s=q.transpose()*m;
|
||||
}
|
||||
else
|
||||
{
|
||||
q.setIdentity();
|
||||
s.setIdentity();
|
||||
}
|
||||
return(i);
|
||||
}
|
||||
|
||||
//
|
||||
// btSoftColliders
|
||||
//
|
||||
struct btSoftColliders
|
||||
{
|
||||
//
|
||||
// ClusterBase
|
||||
//
|
||||
struct ClusterBase : btDbvt::ICollide
|
||||
{
|
||||
btScalar erp;
|
||||
btScalar idt;
|
||||
btScalar m_margin;
|
||||
btScalar friction;
|
||||
btScalar threshold;
|
||||
ClusterBase()
|
||||
{
|
||||
erp =(btScalar)1;
|
||||
idt =0;
|
||||
m_margin =0;
|
||||
friction =0;
|
||||
threshold =(btScalar)0;
|
||||
}
|
||||
bool SolveContact( const btGjkEpaSolver2::sResults& res,
|
||||
btSoftBody::Body ba,btSoftBody::Body bb,
|
||||
btSoftBody::CJoint& joint)
|
||||
{
|
||||
if(res.distance<m_margin)
|
||||
{
|
||||
btVector3 norm = res.normal;
|
||||
norm.normalize();//is it necessary?
|
||||
|
||||
const btVector3 ra=res.witnesses[0]-ba.xform().getOrigin();
|
||||
const btVector3 rb=res.witnesses[1]-bb.xform().getOrigin();
|
||||
const btVector3 va=ba.velocity(ra);
|
||||
const btVector3 vb=bb.velocity(rb);
|
||||
const btVector3 vrel=va-vb;
|
||||
const btScalar rvac=btDot(vrel,norm);
|
||||
btScalar depth=res.distance-m_margin;
|
||||
|
||||
// printf("depth=%f\n",depth);
|
||||
const btVector3 iv=norm*rvac;
|
||||
const btVector3 fv=vrel-iv;
|
||||
joint.m_bodies[0] = ba;
|
||||
joint.m_bodies[1] = bb;
|
||||
joint.m_refs[0] = ra*ba.xform().getBasis();
|
||||
joint.m_refs[1] = rb*bb.xform().getBasis();
|
||||
joint.m_rpos[0] = ra;
|
||||
joint.m_rpos[1] = rb;
|
||||
joint.m_cfm = 1;
|
||||
joint.m_erp = 1;
|
||||
joint.m_life = 0;
|
||||
joint.m_maxlife = 0;
|
||||
joint.m_split = 1;
|
||||
|
||||
joint.m_drift = depth*norm;
|
||||
|
||||
joint.m_normal = norm;
|
||||
// printf("normal=%f,%f,%f\n",res.normal.getX(),res.normal.getY(),res.normal.getZ());
|
||||
joint.m_delete = false;
|
||||
joint.m_friction = fv.length2()<(-rvac*friction)?1:friction;
|
||||
joint.m_massmatrix = ImpulseMatrix( ba.invMass(),ba.invWorldInertia(),joint.m_rpos[0],
|
||||
bb.invMass(),bb.invWorldInertia(),joint.m_rpos[1]);
|
||||
|
||||
return(true);
|
||||
}
|
||||
return(false);
|
||||
}
|
||||
};
|
||||
//
|
||||
// CollideCL_RS
|
||||
//
|
||||
struct CollideCL_RS : ClusterBase
|
||||
{
|
||||
btSoftBody* psb;
|
||||
|
||||
btCollisionObject* m_colObj;
|
||||
void Process(const btDbvtNode* leaf)
|
||||
{
|
||||
btSoftBody::Cluster* cluster=(btSoftBody::Cluster*)leaf->data;
|
||||
btSoftClusterCollisionShape cshape(cluster);
|
||||
|
||||
const btConvexShape* rshape=(const btConvexShape*)m_colObj->getCollisionShape();
|
||||
|
||||
///don't collide an anchored cluster with a static/kinematic object
|
||||
if(m_colObj->isStaticOrKinematicObject() && cluster->m_containsAnchor)
|
||||
return;
|
||||
|
||||
btGjkEpaSolver2::sResults res;
|
||||
if(btGjkEpaSolver2::SignedDistance( &cshape,btTransform::getIdentity(),
|
||||
rshape,m_colObj->getInterpolationWorldTransform(),
|
||||
btVector3(1,0,0),res))
|
||||
{
|
||||
btSoftBody::CJoint joint;
|
||||
if(SolveContact(res,cluster,m_colObj,joint))//prb,joint))
|
||||
{
|
||||
btSoftBody::CJoint* pj=new(btAlignedAlloc(sizeof(btSoftBody::CJoint),16)) btSoftBody::CJoint();
|
||||
*pj=joint;psb->m_joints.push_back(pj);
|
||||
if(m_colObj->isStaticOrKinematicObject())
|
||||
{
|
||||
pj->m_erp *= psb->m_cfg.kSKHR_CL;
|
||||
pj->m_split *= psb->m_cfg.kSK_SPLT_CL;
|
||||
}
|
||||
else
|
||||
{
|
||||
pj->m_erp *= psb->m_cfg.kSRHR_CL;
|
||||
pj->m_split *= psb->m_cfg.kSR_SPLT_CL;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
void Process(btSoftBody* ps,btCollisionObject* colOb)
|
||||
{
|
||||
psb = ps;
|
||||
m_colObj = colOb;
|
||||
idt = ps->m_sst.isdt;
|
||||
m_margin = m_colObj->getCollisionShape()->getMargin()+psb->getCollisionShape()->getMargin();
|
||||
///Bullet rigid body uses multiply instead of minimum to determine combined friction. Some customization would be useful.
|
||||
friction = btMin(psb->m_cfg.kDF,m_colObj->getFriction());
|
||||
btVector3 mins;
|
||||
btVector3 maxs;
|
||||
|
||||
ATTRIBUTE_ALIGNED16(btDbvtVolume) volume;
|
||||
colOb->getCollisionShape()->getAabb(colOb->getInterpolationWorldTransform(),mins,maxs);
|
||||
volume=btDbvtVolume::FromMM(mins,maxs);
|
||||
volume.Expand(btVector3(1,1,1)*m_margin);
|
||||
ps->m_cdbvt.collideTV(ps->m_cdbvt.m_root,volume,*this);
|
||||
}
|
||||
};
|
||||
//
|
||||
// CollideCL_SS
|
||||
//
|
||||
struct CollideCL_SS : ClusterBase
|
||||
{
|
||||
btSoftBody* bodies[2];
|
||||
void Process(const btDbvtNode* la,const btDbvtNode* lb)
|
||||
{
|
||||
btSoftBody::Cluster* cla=(btSoftBody::Cluster*)la->data;
|
||||
btSoftBody::Cluster* clb=(btSoftBody::Cluster*)lb->data;
|
||||
|
||||
|
||||
bool connected=false;
|
||||
if ((bodies[0]==bodies[1])&&(bodies[0]->m_clusterConnectivity.size()))
|
||||
{
|
||||
connected = bodies[0]->m_clusterConnectivity[cla->m_clusterIndex+bodies[0]->m_clusters.size()*clb->m_clusterIndex];
|
||||
}
|
||||
|
||||
if (!connected)
|
||||
{
|
||||
btSoftClusterCollisionShape csa(cla);
|
||||
btSoftClusterCollisionShape csb(clb);
|
||||
btGjkEpaSolver2::sResults res;
|
||||
if(btGjkEpaSolver2::SignedDistance( &csa,btTransform::getIdentity(),
|
||||
&csb,btTransform::getIdentity(),
|
||||
cla->m_com-clb->m_com,res))
|
||||
{
|
||||
btSoftBody::CJoint joint;
|
||||
if(SolveContact(res,cla,clb,joint))
|
||||
{
|
||||
btSoftBody::CJoint* pj=new(btAlignedAlloc(sizeof(btSoftBody::CJoint),16)) btSoftBody::CJoint();
|
||||
*pj=joint;bodies[0]->m_joints.push_back(pj);
|
||||
pj->m_erp *= btMax(bodies[0]->m_cfg.kSSHR_CL,bodies[1]->m_cfg.kSSHR_CL);
|
||||
pj->m_split *= (bodies[0]->m_cfg.kSS_SPLT_CL+bodies[1]->m_cfg.kSS_SPLT_CL)/2;
|
||||
}
|
||||
}
|
||||
} else
|
||||
{
|
||||
static int count=0;
|
||||
count++;
|
||||
//printf("count=%d\n",count);
|
||||
|
||||
}
|
||||
}
|
||||
void Process(btSoftBody* psa,btSoftBody* psb)
|
||||
{
|
||||
idt = psa->m_sst.isdt;
|
||||
//m_margin = (psa->getCollisionShape()->getMargin()+psb->getCollisionShape()->getMargin())/2;
|
||||
m_margin = (psa->getCollisionShape()->getMargin()+psb->getCollisionShape()->getMargin());
|
||||
friction = btMin(psa->m_cfg.kDF,psb->m_cfg.kDF);
|
||||
bodies[0] = psa;
|
||||
bodies[1] = psb;
|
||||
psa->m_cdbvt.collideTT(psa->m_cdbvt.m_root,psb->m_cdbvt.m_root,*this);
|
||||
}
|
||||
};
|
||||
//
|
||||
// CollideSDF_RS
|
||||
//
|
||||
struct CollideSDF_RS : btDbvt::ICollide
|
||||
{
|
||||
void Process(const btDbvtNode* leaf)
|
||||
{
|
||||
btSoftBody::Node* node=(btSoftBody::Node*)leaf->data;
|
||||
DoNode(*node);
|
||||
}
|
||||
void DoNode(btSoftBody::Node& n) const
|
||||
{
|
||||
const btScalar m=n.m_im>0?dynmargin:stamargin;
|
||||
btSoftBody::RContact c;
|
||||
if( (!n.m_battach)&&
|
||||
psb->checkContact(m_colObj1,n.m_x,m,c.m_cti))
|
||||
{
|
||||
const btScalar ima=n.m_im;
|
||||
const btScalar imb= m_rigidBody? m_rigidBody->getInvMass() : 0.f;
|
||||
const btScalar ms=ima+imb;
|
||||
if(ms>0)
|
||||
{
|
||||
const btTransform& wtr=m_rigidBody?m_rigidBody->getInterpolationWorldTransform() : m_colObj1->getWorldTransform();
|
||||
static const btMatrix3x3 iwiStatic(0,0,0,0,0,0,0,0,0);
|
||||
const btMatrix3x3& iwi=m_rigidBody?m_rigidBody->getInvInertiaTensorWorld() : iwiStatic;
|
||||
const btVector3 ra=n.m_x-wtr.getOrigin();
|
||||
const btVector3 va=m_rigidBody ? m_rigidBody->getVelocityInLocalPoint(ra)*psb->m_sst.sdt : btVector3(0,0,0);
|
||||
const btVector3 vb=n.m_x-n.m_q;
|
||||
const btVector3 vr=vb-va;
|
||||
const btScalar dn=btDot(vr,c.m_cti.m_normal);
|
||||
const btVector3 fv=vr-c.m_cti.m_normal*dn;
|
||||
const btScalar fc=psb->m_cfg.kDF*m_colObj1->getFriction();
|
||||
c.m_node = &n;
|
||||
c.m_c0 = ImpulseMatrix(psb->m_sst.sdt,ima,imb,iwi,ra);
|
||||
c.m_c1 = ra;
|
||||
c.m_c2 = ima*psb->m_sst.sdt;
|
||||
c.m_c3 = fv.length2()<(btFabs(dn)*fc)?0:1-fc;
|
||||
c.m_c4 = m_colObj1->isStaticOrKinematicObject()?psb->m_cfg.kKHR:psb->m_cfg.kCHR;
|
||||
psb->m_rcontacts.push_back(c);
|
||||
if (m_rigidBody)
|
||||
m_rigidBody->activate();
|
||||
}
|
||||
}
|
||||
}
|
||||
btSoftBody* psb;
|
||||
btCollisionObject* m_colObj1;
|
||||
btRigidBody* m_rigidBody;
|
||||
btScalar dynmargin;
|
||||
btScalar stamargin;
|
||||
};
|
||||
//
|
||||
// CollideVF_SS
|
||||
//
|
||||
struct CollideVF_SS : btDbvt::ICollide
|
||||
{
|
||||
void Process(const btDbvtNode* lnode,
|
||||
const btDbvtNode* lface)
|
||||
{
|
||||
btSoftBody::Node* node=(btSoftBody::Node*)lnode->data;
|
||||
btSoftBody::Face* face=(btSoftBody::Face*)lface->data;
|
||||
btVector3 o=node->m_x;
|
||||
btVector3 p;
|
||||
btScalar d=SIMD_INFINITY;
|
||||
ProjectOrigin( face->m_n[0]->m_x-o,
|
||||
face->m_n[1]->m_x-o,
|
||||
face->m_n[2]->m_x-o,
|
||||
p,d);
|
||||
const btScalar m=mrg+(o-node->m_q).length()*2;
|
||||
if(d<(m*m))
|
||||
{
|
||||
const btSoftBody::Node* n[]={face->m_n[0],face->m_n[1],face->m_n[2]};
|
||||
const btVector3 w=BaryCoord(n[0]->m_x,n[1]->m_x,n[2]->m_x,p+o);
|
||||
const btScalar ma=node->m_im;
|
||||
btScalar mb=BaryEval(n[0]->m_im,n[1]->m_im,n[2]->m_im,w);
|
||||
if( (n[0]->m_im<=0)||
|
||||
(n[1]->m_im<=0)||
|
||||
(n[2]->m_im<=0))
|
||||
{
|
||||
mb=0;
|
||||
}
|
||||
const btScalar ms=ma+mb;
|
||||
if(ms>0)
|
||||
{
|
||||
btSoftBody::SContact c;
|
||||
c.m_normal = p/-btSqrt(d);
|
||||
c.m_margin = m;
|
||||
c.m_node = node;
|
||||
c.m_face = face;
|
||||
c.m_weights = w;
|
||||
c.m_friction = btMax(psb[0]->m_cfg.kDF,psb[1]->m_cfg.kDF);
|
||||
c.m_cfm[0] = ma/ms*psb[0]->m_cfg.kSHR;
|
||||
c.m_cfm[1] = mb/ms*psb[1]->m_cfg.kSHR;
|
||||
psb[0]->m_scontacts.push_back(c);
|
||||
}
|
||||
}
|
||||
}
|
||||
btSoftBody* psb[2];
|
||||
btScalar mrg;
|
||||
};
|
||||
};
|
||||
|
||||
#endif //_BT_SOFT_BODY_INTERNALS_H
|
||||
|
|
@ -0,0 +1,48 @@
|
|||
/*
|
||||
Bullet Continuous Collision Detection and Physics Library
|
||||
Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/
|
||||
|
||||
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 BT_SOFTBODY_RIGIDBODY_COLLISION_CONFIGURATION
|
||||
#define BT_SOFTBODY_RIGIDBODY_COLLISION_CONFIGURATION
|
||||
|
||||
#include "BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h"
|
||||
|
||||
class btVoronoiSimplexSolver;
|
||||
class btGjkEpaPenetrationDepthSolver;
|
||||
|
||||
|
||||
///btSoftBodyRigidBodyCollisionConfiguration add softbody interaction on top of btDefaultCollisionConfiguration
|
||||
class btSoftBodyRigidBodyCollisionConfiguration : public btDefaultCollisionConfiguration
|
||||
{
|
||||
|
||||
//default CreationFunctions, filling the m_doubleDispatch table
|
||||
btCollisionAlgorithmCreateFunc* m_softSoftCreateFunc;
|
||||
btCollisionAlgorithmCreateFunc* m_softRigidConvexCreateFunc;
|
||||
btCollisionAlgorithmCreateFunc* m_swappedSoftRigidConvexCreateFunc;
|
||||
btCollisionAlgorithmCreateFunc* m_softRigidConcaveCreateFunc;
|
||||
btCollisionAlgorithmCreateFunc* m_swappedSoftRigidConcaveCreateFunc;
|
||||
|
||||
public:
|
||||
|
||||
btSoftBodyRigidBodyCollisionConfiguration(const btDefaultCollisionConstructionInfo& constructionInfo = btDefaultCollisionConstructionInfo());
|
||||
|
||||
virtual ~btSoftBodyRigidBodyCollisionConfiguration();
|
||||
|
||||
///creation of soft-soft and soft-rigid, and otherwise fallback to base class implementation
|
||||
virtual btCollisionAlgorithmCreateFunc* getCollisionAlgorithmCreateFunc(int proxyType0,int proxyType1);
|
||||
|
||||
};
|
||||
|
||||
#endif //BT_SOFTBODY_RIGIDBODY_COLLISION_CONFIGURATION
|
||||
|
||||
|
|
@ -0,0 +1,165 @@
|
|||
/*
|
||||
Bullet Continuous Collision Detection and Physics Library
|
||||
Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/
|
||||
|
||||
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 BT_SOFT_BODY_SOLVER_VERTEX_BUFFER_H
|
||||
#define BT_SOFT_BODY_SOLVER_VERTEX_BUFFER_H
|
||||
|
||||
|
||||
class btVertexBufferDescriptor
|
||||
{
|
||||
public:
|
||||
enum BufferTypes
|
||||
{
|
||||
CPU_BUFFER,
|
||||
DX11_BUFFER,
|
||||
OPENGL_BUFFER
|
||||
};
|
||||
|
||||
protected:
|
||||
|
||||
bool m_hasVertexPositions;
|
||||
bool m_hasNormals;
|
||||
|
||||
int m_vertexOffset;
|
||||
int m_vertexStride;
|
||||
|
||||
int m_normalOffset;
|
||||
int m_normalStride;
|
||||
|
||||
public:
|
||||
btVertexBufferDescriptor()
|
||||
{
|
||||
m_hasVertexPositions = false;
|
||||
m_hasNormals = false;
|
||||
m_vertexOffset = 0;
|
||||
m_vertexStride = 0;
|
||||
m_normalOffset = 0;
|
||||
m_normalStride = 0;
|
||||
}
|
||||
|
||||
virtual ~btVertexBufferDescriptor()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
virtual bool hasVertexPositions() const
|
||||
{
|
||||
return m_hasVertexPositions;
|
||||
}
|
||||
|
||||
virtual bool hasNormals() const
|
||||
{
|
||||
return m_hasNormals;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the type of the vertex buffer descriptor.
|
||||
*/
|
||||
virtual BufferTypes getBufferType() const = 0;
|
||||
|
||||
/**
|
||||
* Return the vertex offset in floats from the base pointer.
|
||||
*/
|
||||
virtual int getVertexOffset() const
|
||||
{
|
||||
return m_vertexOffset;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the vertex stride in number of floats between vertices.
|
||||
*/
|
||||
virtual int getVertexStride() const
|
||||
{
|
||||
return m_vertexStride;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the vertex offset in floats from the base pointer.
|
||||
*/
|
||||
virtual int getNormalOffset() const
|
||||
{
|
||||
return m_normalOffset;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the vertex stride in number of floats between vertices.
|
||||
*/
|
||||
virtual int getNormalStride() const
|
||||
{
|
||||
return m_normalStride;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
class btCPUVertexBufferDescriptor : public btVertexBufferDescriptor
|
||||
{
|
||||
protected:
|
||||
float *m_basePointer;
|
||||
|
||||
public:
|
||||
/**
|
||||
* vertexBasePointer is pointer to beginning of the buffer.
|
||||
* vertexOffset is the offset in floats to the first vertex.
|
||||
* vertexStride is the stride in floats between vertices.
|
||||
*/
|
||||
btCPUVertexBufferDescriptor( float *basePointer, int vertexOffset, int vertexStride )
|
||||
{
|
||||
m_basePointer = basePointer;
|
||||
m_vertexOffset = vertexOffset;
|
||||
m_vertexStride = vertexStride;
|
||||
m_hasVertexPositions = true;
|
||||
}
|
||||
|
||||
/**
|
||||
* vertexBasePointer is pointer to beginning of the buffer.
|
||||
* vertexOffset is the offset in floats to the first vertex.
|
||||
* vertexStride is the stride in floats between vertices.
|
||||
*/
|
||||
btCPUVertexBufferDescriptor( float *basePointer, int vertexOffset, int vertexStride, int normalOffset, int normalStride )
|
||||
{
|
||||
m_basePointer = basePointer;
|
||||
|
||||
m_vertexOffset = vertexOffset;
|
||||
m_vertexStride = vertexStride;
|
||||
m_hasVertexPositions = true;
|
||||
|
||||
m_normalOffset = normalOffset;
|
||||
m_normalStride = normalStride;
|
||||
m_hasNormals = true;
|
||||
}
|
||||
|
||||
virtual ~btCPUVertexBufferDescriptor()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the type of the vertex buffer descriptor.
|
||||
*/
|
||||
virtual BufferTypes getBufferType() const
|
||||
{
|
||||
return CPU_BUFFER;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the base pointer in memory to the first vertex.
|
||||
*/
|
||||
virtual float *getBasePointer() const
|
||||
{
|
||||
return m_basePointer;
|
||||
}
|
||||
};
|
||||
|
||||
#endif // #ifndef BT_SOFT_BODY_SOLVER_VERTEX_BUFFER_H
|
||||
|
|
@ -0,0 +1,142 @@
|
|||
/*
|
||||
Bullet Continuous Collision Detection and Physics Library
|
||||
Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/
|
||||
|
||||
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 BT_SOFT_BODY_SOLVERS_H
|
||||
#define BT_SOFT_BODY_SOLVERS_H
|
||||
|
||||
#include "BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h"
|
||||
|
||||
|
||||
class btSoftBodyTriangleData;
|
||||
class btSoftBodyLinkData;
|
||||
class btSoftBodyVertexData;
|
||||
class btVertexBufferDescriptor;
|
||||
class btCollisionObject;
|
||||
class btSoftBody;
|
||||
|
||||
|
||||
class btSoftBodySolver
|
||||
{
|
||||
|
||||
protected:
|
||||
int m_numberOfPositionIterations;
|
||||
int m_numberOfVelocityIterations;
|
||||
// Simulation timescale
|
||||
float m_timeScale;
|
||||
|
||||
public:
|
||||
btSoftBodySolver() :
|
||||
m_numberOfPositionIterations( 10 ),
|
||||
m_timeScale( 1 )
|
||||
{
|
||||
m_numberOfVelocityIterations = 0;
|
||||
m_numberOfPositionIterations = 5;
|
||||
}
|
||||
|
||||
virtual ~btSoftBodySolver()
|
||||
{
|
||||
}
|
||||
|
||||
#if 0
|
||||
/** Acceleration for all cloths in the solver. Can be used to efficiently apply gravity. */
|
||||
virtual void setPerClothAcceleration( int clothIdentifier, Vectormath::Aos::Vector3 acceleration ) = 0;
|
||||
|
||||
/** A wind velocity applied normal to the cloth for all cloths in the solver. */
|
||||
virtual void setPerClothWindVelocity( int clothIdentifier, Vectormath::Aos::Vector3 windVelocity ) = 0;
|
||||
|
||||
/** Set the density of the medium a given cloth is situated in. This could be air or possibly water. */
|
||||
virtual void setPerClothMediumDensity( int clothIdentifier, float mediumDensity ) = 0;
|
||||
|
||||
/** A damping factor specific to each cloth applied for all cloths. */
|
||||
virtual void setPerClothDampingFactor( int clothIdentifier, float dampingFactor ) = 0;
|
||||
|
||||
/** A damping factor specific to each cloth applied for all cloths. */
|
||||
virtual void setPerClothVelocityCorrectionCoefficient( int clothIdentifier, float velocityCorrectionCoefficient ) = 0;
|
||||
|
||||
/** Lift parameter for wind action on cloth. */
|
||||
virtual void setPerClothLiftFactor( int clothIdentifier, float liftFactor ) = 0;
|
||||
|
||||
/** Drag parameter for wind action on cloth. */
|
||||
virtual void setPerClothDragFactor( int clothIdentifier, float dragFactor ) = 0;
|
||||
|
||||
/**
|
||||
* Add a velocity to all soft bodies in the solver - useful for doing world-wide velocities such as a change due to gravity
|
||||
* Only add a velocity to nodes with a non-zero inverse mass.
|
||||
*/
|
||||
virtual void addVelocity( Vectormath::Aos::Vector3 velocity ) = 0;
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
/** Ensure that this solver is initialized. */
|
||||
virtual bool checkInitialized() = 0;
|
||||
|
||||
/** Optimize soft bodies in this solver. */
|
||||
virtual void optimize( btAlignedObjectArray< btSoftBody * > &softBodies ) = 0;
|
||||
|
||||
/** Predict motion of soft bodies into next timestep */
|
||||
virtual void predictMotion( float solverdt ) = 0;
|
||||
|
||||
/** Solve constraints for a set of soft bodies */
|
||||
virtual void solveConstraints( float solverdt ) = 0;
|
||||
|
||||
/** Perform necessary per-step updates of soft bodies such as recomputing normals and bounding boxes */
|
||||
virtual void updateSoftBodies() = 0;
|
||||
|
||||
/** Output current computed vertex data to the vertex buffers for all cloths in the solver. */
|
||||
virtual void copySoftBodyToVertexBuffer( const btSoftBody * const softBody, btVertexBufferDescriptor *vertexBuffer ) = 0;
|
||||
|
||||
|
||||
|
||||
/** Set the number of velocity constraint solver iterations this solver uses. */
|
||||
virtual void setNumberOfPositionIterations( int iterations )
|
||||
{
|
||||
m_numberOfPositionIterations = iterations;
|
||||
}
|
||||
|
||||
/** Get the number of velocity constraint solver iterations this solver uses. */
|
||||
virtual int getNumberOfPositionIterations()
|
||||
{
|
||||
return m_numberOfPositionIterations;
|
||||
}
|
||||
|
||||
/** Set the number of velocity constraint solver iterations this solver uses. */
|
||||
virtual void setNumberOfVelocityIterations( int iterations )
|
||||
{
|
||||
m_numberOfVelocityIterations = iterations;
|
||||
}
|
||||
|
||||
/** Get the number of velocity constraint solver iterations this solver uses. */
|
||||
virtual int getNumberOfVelocityIterations()
|
||||
{
|
||||
return m_numberOfVelocityIterations;
|
||||
}
|
||||
|
||||
/** Return the timescale that the simulation is using */
|
||||
float getTimeScale()
|
||||
{
|
||||
return m_timeScale;
|
||||
}
|
||||
|
||||
#if 0
|
||||
/**
|
||||
* Add a collision object to be used by the indicated softbody.
|
||||
*/
|
||||
virtual void addCollisionObjectForSoftBody( int clothIdentifier, btCollisionObject *collisionObject ) = 0;
|
||||
#endif
|
||||
};
|
||||
|
||||
|
||||
#endif // #ifndef BT_SOFT_BODY_SOLVERS_H
|
||||
|
|
@ -0,0 +1,75 @@
|
|||
/*
|
||||
Bullet Continuous Collision Detection and Physics Library
|
||||
Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/
|
||||
|
||||
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 SOFT_RIGID_COLLISION_ALGORITHM_H
|
||||
#define SOFT_RIGID_COLLISION_ALGORITHM_H
|
||||
|
||||
#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
|
||||
#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
|
||||
#include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h"
|
||||
class btPersistentManifold;
|
||||
#include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h"
|
||||
|
||||
#include "LinearMath/btVector3.h"
|
||||
class btSoftBody;
|
||||
|
||||
/// btSoftRigidCollisionAlgorithm provides collision detection between btSoftBody and btRigidBody
|
||||
class btSoftRigidCollisionAlgorithm : public btCollisionAlgorithm
|
||||
{
|
||||
// bool m_ownManifold;
|
||||
// btPersistentManifold* m_manifoldPtr;
|
||||
|
||||
btSoftBody* m_softBody;
|
||||
btCollisionObject* m_rigidCollisionObject;
|
||||
|
||||
///for rigid versus soft (instead of soft versus rigid), we use this swapped boolean
|
||||
bool m_isSwapped;
|
||||
|
||||
public:
|
||||
|
||||
btSoftRigidCollisionAlgorithm(btPersistentManifold* mf,const btCollisionAlgorithmConstructionInfo& ci,btCollisionObject* col0,btCollisionObject* col1, bool isSwapped);
|
||||
|
||||
virtual ~btSoftRigidCollisionAlgorithm();
|
||||
|
||||
virtual void processCollision (btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
|
||||
|
||||
virtual btScalar calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
|
||||
|
||||
virtual void getAllContactManifolds(btManifoldArray& manifoldArray)
|
||||
{
|
||||
//we don't add any manifolds
|
||||
}
|
||||
|
||||
|
||||
struct CreateFunc :public btCollisionAlgorithmCreateFunc
|
||||
{
|
||||
virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, btCollisionObject* body0,btCollisionObject* body1)
|
||||
{
|
||||
void* mem = ci.m_dispatcher1->allocateCollisionAlgorithm(sizeof(btSoftRigidCollisionAlgorithm));
|
||||
if (!m_swapped)
|
||||
{
|
||||
return new(mem) btSoftRigidCollisionAlgorithm(0,ci,body0,body1,false);
|
||||
} else
|
||||
{
|
||||
return new(mem) btSoftRigidCollisionAlgorithm(0,ci,body0,body1,true);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
};
|
||||
|
||||
#endif //SOFT_RIGID_COLLISION_ALGORITHM_H
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,101 @@
|
|||
/*
|
||||
Bullet Continuous Collision Detection and Physics Library
|
||||
Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/
|
||||
|
||||
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 BT_SOFT_RIGID_DYNAMICS_WORLD_H
|
||||
#define BT_SOFT_RIGID_DYNAMICS_WORLD_H
|
||||
|
||||
#include "BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h"
|
||||
#include "btSoftBody.h"
|
||||
|
||||
typedef btAlignedObjectArray<btSoftBody*> btSoftBodyArray;
|
||||
|
||||
class btSoftBodySolver;
|
||||
|
||||
class btSoftRigidDynamicsWorld : public btDiscreteDynamicsWorld
|
||||
{
|
||||
|
||||
btSoftBodyArray m_softBodies;
|
||||
int m_drawFlags;
|
||||
bool m_drawNodeTree;
|
||||
bool m_drawFaceTree;
|
||||
bool m_drawClusterTree;
|
||||
btSoftBodyWorldInfo m_sbi;
|
||||
///Solver classes that encapsulate multiple soft bodies for solving
|
||||
btSoftBodySolver *m_softBodySolver;
|
||||
bool m_ownsSolver;
|
||||
|
||||
protected:
|
||||
|
||||
virtual void predictUnconstraintMotion(btScalar timeStep);
|
||||
|
||||
virtual void internalSingleStepSimulation( btScalar timeStep);
|
||||
|
||||
void solveSoftBodiesConstraints( btScalar timeStep );
|
||||
|
||||
|
||||
public:
|
||||
|
||||
btSoftRigidDynamicsWorld(btDispatcher* dispatcher,btBroadphaseInterface* pairCache,btConstraintSolver* constraintSolver, btCollisionConfiguration* collisionConfiguration, btSoftBodySolver *softBodySolver = 0 );
|
||||
|
||||
virtual ~btSoftRigidDynamicsWorld();
|
||||
|
||||
virtual void debugDrawWorld();
|
||||
|
||||
void addSoftBody(btSoftBody* body,short int collisionFilterGroup=btBroadphaseProxy::DefaultFilter,short int collisionFilterMask=btBroadphaseProxy::AllFilter);
|
||||
|
||||
void removeSoftBody(btSoftBody* body);
|
||||
|
||||
///removeCollisionObject will first check if it is a rigid body, if so call removeRigidBody otherwise call btDiscreteDynamicsWorld::removeCollisionObject
|
||||
virtual void removeCollisionObject(btCollisionObject* collisionObject);
|
||||
|
||||
int getDrawFlags() const { return(m_drawFlags); }
|
||||
void setDrawFlags(int f) { m_drawFlags=f; }
|
||||
|
||||
btSoftBodyWorldInfo& getWorldInfo()
|
||||
{
|
||||
return m_sbi;
|
||||
}
|
||||
const btSoftBodyWorldInfo& getWorldInfo() const
|
||||
{
|
||||
return m_sbi;
|
||||
}
|
||||
|
||||
|
||||
btSoftBodyArray& getSoftBodyArray()
|
||||
{
|
||||
return m_softBodies;
|
||||
}
|
||||
|
||||
const btSoftBodyArray& getSoftBodyArray() const
|
||||
{
|
||||
return m_softBodies;
|
||||
}
|
||||
|
||||
|
||||
virtual void rayTest(const btVector3& rayFromWorld, const btVector3& rayToWorld, RayResultCallback& resultCallback) const;
|
||||
|
||||
/// rayTestSingle performs a raycast call and calls the resultCallback. It is used internally by rayTest.
|
||||
/// In a future implementation, we consider moving the ray test as a virtual method in btCollisionShape.
|
||||
/// This allows more customization.
|
||||
static void rayTestSingle(const btTransform& rayFromTrans,const btTransform& rayToTrans,
|
||||
btCollisionObject* collisionObject,
|
||||
const btCollisionShape* collisionShape,
|
||||
const btTransform& colObjWorldTransform,
|
||||
RayResultCallback& resultCallback);
|
||||
|
||||
|
||||
};
|
||||
|
||||
#endif //BT_SOFT_RIGID_DYNAMICS_WORLD_H
|
||||
|
|
@ -0,0 +1,69 @@
|
|||
/*
|
||||
Bullet Continuous Collision Detection and Physics Library
|
||||
Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/
|
||||
|
||||
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 SOFT_SOFT_COLLISION_ALGORITHM_H
|
||||
#define SOFT_SOFT_COLLISION_ALGORITHM_H
|
||||
|
||||
#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
|
||||
#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
|
||||
#include "BulletCollision/BroadphaseCollision/btDispatcher.h"
|
||||
#include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h"
|
||||
|
||||
class btPersistentManifold;
|
||||
class btSoftBody;
|
||||
|
||||
///collision detection between two btSoftBody shapes
|
||||
class btSoftSoftCollisionAlgorithm : public btCollisionAlgorithm
|
||||
{
|
||||
bool m_ownManifold;
|
||||
btPersistentManifold* m_manifoldPtr;
|
||||
|
||||
btSoftBody* m_softBody0;
|
||||
btSoftBody* m_softBody1;
|
||||
|
||||
|
||||
public:
|
||||
btSoftSoftCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci)
|
||||
: btCollisionAlgorithm(ci) {}
|
||||
|
||||
virtual void processCollision (btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
|
||||
|
||||
virtual btScalar calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
|
||||
|
||||
virtual void getAllContactManifolds(btManifoldArray& manifoldArray)
|
||||
{
|
||||
if (m_manifoldPtr && m_ownManifold)
|
||||
manifoldArray.push_back(m_manifoldPtr);
|
||||
}
|
||||
|
||||
btSoftSoftCollisionAlgorithm(btPersistentManifold* mf,const btCollisionAlgorithmConstructionInfo& ci,btCollisionObject* body0,btCollisionObject* body1);
|
||||
|
||||
virtual ~btSoftSoftCollisionAlgorithm();
|
||||
|
||||
struct CreateFunc :public btCollisionAlgorithmCreateFunc
|
||||
{
|
||||
virtual btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, btCollisionObject* body0,btCollisionObject* body1)
|
||||
{
|
||||
int bbsize = sizeof(btSoftSoftCollisionAlgorithm);
|
||||
void* ptr = ci.m_dispatcher1->allocateCollisionAlgorithm(bbsize);
|
||||
return new(ptr) btSoftSoftCollisionAlgorithm(0,ci,body0,body1);
|
||||
}
|
||||
};
|
||||
|
||||
};
|
||||
|
||||
#endif //SOFT_SOFT_COLLISION_ALGORITHM_H
|
||||
|
||||
|
||||
306
Mod Sources/Bullet/include/bullet/BulletSoftBody/btSparseSDF.h
Normal file
306
Mod Sources/Bullet/include/bullet/BulletSoftBody/btSparseSDF.h
Normal file
|
|
@ -0,0 +1,306 @@
|
|||
/*
|
||||
Bullet Continuous Collision Detection and Physics Library
|
||||
Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/
|
||||
|
||||
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.
|
||||
*/
|
||||
///btSparseSdf implementation by Nathanael Presson
|
||||
|
||||
#ifndef _14F9D17F_EAE8_4aba_B41C_292DB2AA70F3_
|
||||
#define _14F9D17F_EAE8_4aba_B41C_292DB2AA70F3_
|
||||
|
||||
#include "BulletCollision/CollisionDispatch/btCollisionObject.h"
|
||||
#include "BulletCollision/NarrowPhaseCollision/btGjkEpa2.h"
|
||||
|
||||
// Modified Paul Hsieh hash
|
||||
template <const int DWORDLEN>
|
||||
unsigned int HsiehHash(const void* pdata)
|
||||
{
|
||||
const unsigned short* data=(const unsigned short*)pdata;
|
||||
unsigned hash=DWORDLEN<<2,tmp;
|
||||
for(int i=0;i<DWORDLEN;++i)
|
||||
{
|
||||
hash += data[0];
|
||||
tmp = (data[1]<<11)^hash;
|
||||
hash = (hash<<16)^tmp;
|
||||
data += 2;
|
||||
hash += hash>>11;
|
||||
}
|
||||
hash^=hash<<3;hash+=hash>>5;
|
||||
hash^=hash<<4;hash+=hash>>17;
|
||||
hash^=hash<<25;hash+=hash>>6;
|
||||
return(hash);
|
||||
}
|
||||
|
||||
template <const int CELLSIZE>
|
||||
struct btSparseSdf
|
||||
{
|
||||
//
|
||||
// Inner types
|
||||
//
|
||||
struct IntFrac
|
||||
{
|
||||
int b;
|
||||
int i;
|
||||
btScalar f;
|
||||
};
|
||||
struct Cell
|
||||
{
|
||||
btScalar d[CELLSIZE+1][CELLSIZE+1][CELLSIZE+1];
|
||||
int c[3];
|
||||
int puid;
|
||||
unsigned hash;
|
||||
btCollisionShape* pclient;
|
||||
Cell* next;
|
||||
};
|
||||
//
|
||||
// Fields
|
||||
//
|
||||
|
||||
btAlignedObjectArray<Cell*> cells;
|
||||
btScalar voxelsz;
|
||||
int puid;
|
||||
int ncells;
|
||||
int nprobes;
|
||||
int nqueries;
|
||||
|
||||
//
|
||||
// Methods
|
||||
//
|
||||
|
||||
//
|
||||
void Initialize(int hashsize=2383)
|
||||
{
|
||||
cells.resize(hashsize,0);
|
||||
Reset();
|
||||
}
|
||||
//
|
||||
void Reset()
|
||||
{
|
||||
for(int i=0,ni=cells.size();i<ni;++i)
|
||||
{
|
||||
Cell* pc=cells[i];
|
||||
cells[i]=0;
|
||||
while(pc)
|
||||
{
|
||||
Cell* pn=pc->next;
|
||||
delete pc;
|
||||
pc=pn;
|
||||
}
|
||||
}
|
||||
voxelsz =0.25;
|
||||
puid =0;
|
||||
ncells =0;
|
||||
nprobes =1;
|
||||
nqueries =1;
|
||||
}
|
||||
//
|
||||
void GarbageCollect(int lifetime=256)
|
||||
{
|
||||
const int life=puid-lifetime;
|
||||
for(int i=0;i<cells.size();++i)
|
||||
{
|
||||
Cell*& root=cells[i];
|
||||
Cell* pp=0;
|
||||
Cell* pc=root;
|
||||
while(pc)
|
||||
{
|
||||
Cell* pn=pc->next;
|
||||
if(pc->puid<life)
|
||||
{
|
||||
if(pp) pp->next=pn; else root=pn;
|
||||
delete pc;pc=pp;--ncells;
|
||||
}
|
||||
pp=pc;pc=pn;
|
||||
}
|
||||
}
|
||||
//printf("GC[%d]: %d cells, PpQ: %f\r\n",puid,ncells,nprobes/(btScalar)nqueries);
|
||||
nqueries=1;
|
||||
nprobes=1;
|
||||
++puid; ///@todo: Reset puid's when int range limit is reached */
|
||||
/* else setup a priority list... */
|
||||
}
|
||||
//
|
||||
int RemoveReferences(btCollisionShape* pcs)
|
||||
{
|
||||
int refcount=0;
|
||||
for(int i=0;i<cells.size();++i)
|
||||
{
|
||||
Cell*& root=cells[i];
|
||||
Cell* pp=0;
|
||||
Cell* pc=root;
|
||||
while(pc)
|
||||
{
|
||||
Cell* pn=pc->next;
|
||||
if(pc->pclient==pcs)
|
||||
{
|
||||
if(pp) pp->next=pn; else root=pn;
|
||||
delete pc;pc=pp;++refcount;
|
||||
}
|
||||
pp=pc;pc=pn;
|
||||
}
|
||||
}
|
||||
return(refcount);
|
||||
}
|
||||
//
|
||||
btScalar Evaluate( const btVector3& x,
|
||||
btCollisionShape* shape,
|
||||
btVector3& normal,
|
||||
btScalar margin)
|
||||
{
|
||||
/* Lookup cell */
|
||||
const btVector3 scx=x/voxelsz;
|
||||
const IntFrac ix=Decompose(scx.x());
|
||||
const IntFrac iy=Decompose(scx.y());
|
||||
const IntFrac iz=Decompose(scx.z());
|
||||
const unsigned h=Hash(ix.b,iy.b,iz.b,shape);
|
||||
Cell*& root=cells[static_cast<int>(h%cells.size())];
|
||||
Cell* c=root;
|
||||
++nqueries;
|
||||
while(c)
|
||||
{
|
||||
++nprobes;
|
||||
if( (c->hash==h) &&
|
||||
(c->c[0]==ix.b) &&
|
||||
(c->c[1]==iy.b) &&
|
||||
(c->c[2]==iz.b) &&
|
||||
(c->pclient==shape))
|
||||
{ break; }
|
||||
else
|
||||
{ c=c->next; }
|
||||
}
|
||||
if(!c)
|
||||
{
|
||||
++nprobes;
|
||||
++ncells;
|
||||
c=new Cell();
|
||||
c->next=root;root=c;
|
||||
c->pclient=shape;
|
||||
c->hash=h;
|
||||
c->c[0]=ix.b;c->c[1]=iy.b;c->c[2]=iz.b;
|
||||
BuildCell(*c);
|
||||
}
|
||||
c->puid=puid;
|
||||
/* Extract infos */
|
||||
const int o[]={ ix.i,iy.i,iz.i};
|
||||
const btScalar d[]={ c->d[o[0]+0][o[1]+0][o[2]+0],
|
||||
c->d[o[0]+1][o[1]+0][o[2]+0],
|
||||
c->d[o[0]+1][o[1]+1][o[2]+0],
|
||||
c->d[o[0]+0][o[1]+1][o[2]+0],
|
||||
c->d[o[0]+0][o[1]+0][o[2]+1],
|
||||
c->d[o[0]+1][o[1]+0][o[2]+1],
|
||||
c->d[o[0]+1][o[1]+1][o[2]+1],
|
||||
c->d[o[0]+0][o[1]+1][o[2]+1]};
|
||||
/* Normal */
|
||||
#if 1
|
||||
const btScalar gx[]={ d[1]-d[0],d[2]-d[3],
|
||||
d[5]-d[4],d[6]-d[7]};
|
||||
const btScalar gy[]={ d[3]-d[0],d[2]-d[1],
|
||||
d[7]-d[4],d[6]-d[5]};
|
||||
const btScalar gz[]={ d[4]-d[0],d[5]-d[1],
|
||||
d[7]-d[3],d[6]-d[2]};
|
||||
normal.setX(Lerp( Lerp(gx[0],gx[1],iy.f),
|
||||
Lerp(gx[2],gx[3],iy.f),iz.f));
|
||||
normal.setY(Lerp( Lerp(gy[0],gy[1],ix.f),
|
||||
Lerp(gy[2],gy[3],ix.f),iz.f));
|
||||
normal.setZ(Lerp( Lerp(gz[0],gz[1],ix.f),
|
||||
Lerp(gz[2],gz[3],ix.f),iy.f));
|
||||
normal = normal.normalized();
|
||||
#else
|
||||
normal = btVector3(d[1]-d[0],d[3]-d[0],d[4]-d[0]).normalized();
|
||||
#endif
|
||||
/* Distance */
|
||||
const btScalar d0=Lerp(Lerp(d[0],d[1],ix.f),
|
||||
Lerp(d[3],d[2],ix.f),iy.f);
|
||||
const btScalar d1=Lerp(Lerp(d[4],d[5],ix.f),
|
||||
Lerp(d[7],d[6],ix.f),iy.f);
|
||||
return(Lerp(d0,d1,iz.f)-margin);
|
||||
}
|
||||
//
|
||||
void BuildCell(Cell& c)
|
||||
{
|
||||
const btVector3 org=btVector3( (btScalar)c.c[0],
|
||||
(btScalar)c.c[1],
|
||||
(btScalar)c.c[2]) *
|
||||
CELLSIZE*voxelsz;
|
||||
for(int k=0;k<=CELLSIZE;++k)
|
||||
{
|
||||
const btScalar z=voxelsz*k+org.z();
|
||||
for(int j=0;j<=CELLSIZE;++j)
|
||||
{
|
||||
const btScalar y=voxelsz*j+org.y();
|
||||
for(int i=0;i<=CELLSIZE;++i)
|
||||
{
|
||||
const btScalar x=voxelsz*i+org.x();
|
||||
c.d[i][j][k]=DistanceToShape( btVector3(x,y,z),
|
||||
c.pclient);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
//
|
||||
static inline btScalar DistanceToShape(const btVector3& x,
|
||||
btCollisionShape* shape)
|
||||
{
|
||||
btTransform unit;
|
||||
unit.setIdentity();
|
||||
if(shape->isConvex())
|
||||
{
|
||||
btGjkEpaSolver2::sResults res;
|
||||
btConvexShape* csh=static_cast<btConvexShape*>(shape);
|
||||
return(btGjkEpaSolver2::SignedDistance(x,0,csh,unit,res));
|
||||
}
|
||||
return(0);
|
||||
}
|
||||
//
|
||||
static inline IntFrac Decompose(btScalar x)
|
||||
{
|
||||
/* That one need a lot of improvements... */
|
||||
/* Remove test, faster floor... */
|
||||
IntFrac r;
|
||||
x/=CELLSIZE;
|
||||
const int o=x<0?(int)(-x+1):0;
|
||||
x+=o;r.b=(int)x;
|
||||
const btScalar k=(x-r.b)*CELLSIZE;
|
||||
r.i=(int)k;r.f=k-r.i;r.b-=o;
|
||||
return(r);
|
||||
}
|
||||
//
|
||||
static inline btScalar Lerp(btScalar a,btScalar b,btScalar t)
|
||||
{
|
||||
return(a+(b-a)*t);
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
static inline unsigned int Hash(int x,int y,int z,btCollisionShape* shape)
|
||||
{
|
||||
struct btS
|
||||
{
|
||||
int x,y,z;
|
||||
void* p;
|
||||
};
|
||||
|
||||
btS myset;
|
||||
|
||||
myset.x=x;myset.y=y;myset.z=z;myset.p=shape;
|
||||
const void* ptr = &myset;
|
||||
|
||||
unsigned int result = HsiehHash<sizeof(btS)/4> (ptr);
|
||||
|
||||
|
||||
return result;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
# Install script for directory: C:/Documents and Settings/Robert MacGregor/Desktop/bullet-2.77/src/BulletSoftBody
|
||||
|
||||
# Set the install prefix
|
||||
IF(NOT DEFINED CMAKE_INSTALL_PREFIX)
|
||||
SET(CMAKE_INSTALL_PREFIX "C:/Program Files/BULLET_PHYSICS")
|
||||
ENDIF(NOT DEFINED CMAKE_INSTALL_PREFIX)
|
||||
STRING(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
|
||||
|
||||
# Set the install configuration name.
|
||||
IF(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME)
|
||||
IF(BUILD_TYPE)
|
||||
STRING(REGEX REPLACE "^[^A-Za-z0-9_]+" ""
|
||||
CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}")
|
||||
ELSE(BUILD_TYPE)
|
||||
SET(CMAKE_INSTALL_CONFIG_NAME "Release")
|
||||
ENDIF(BUILD_TYPE)
|
||||
MESSAGE(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"")
|
||||
ENDIF(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME)
|
||||
|
||||
# Set the component getting installed.
|
||||
IF(NOT CMAKE_INSTALL_COMPONENT)
|
||||
IF(COMPONENT)
|
||||
MESSAGE(STATUS "Install component: \"${COMPONENT}\"")
|
||||
SET(CMAKE_INSTALL_COMPONENT "${COMPONENT}")
|
||||
ELSE(COMPONENT)
|
||||
SET(CMAKE_INSTALL_COMPONENT)
|
||||
ENDIF(COMPONENT)
|
||||
ENDIF(NOT CMAKE_INSTALL_COMPONENT)
|
||||
|
||||
Loading…
Add table
Add a link
Reference in a new issue